x2:\\n\\t\\t\\t\\tx2 = symbol.bounding_box.vertices[2].x\\n\\t\\t\\tif symbol.bounding_box.vertices[2].y > y2:\\n\\t\\t\\t\\ty2 = symbol.bounding_box.vertices[2].y\\n\\t\\t\\tif symbol.bounding_box.vertices[1].x > x2:\\n\\t\\t\\t\\tx2 = symbol.bounding_box.vertices[1].x\\n\\t\\t\\tif symbol.bounding_box.vertices[3].y > y2:\\n\\t\\t\\t\\ty2 = symbol.bounding_box.vertices[3].y\\n\\n\\t\\t\\tcurrent_line_text.append( symbol.text )\\n\\t\\t\\tcurrent_line_prob.append( symbol.confidence )\\n\\t\\t\\t# Check for blank spaces\\n\\t\\t\\tif symbol.property.detected_break.type in [ breaks.SPACE, breaks.SURE_SPACE ]:\\n\\t\\t\\t\\tcurrent_line_text.append( ' ' )\\n\\t\\t\\t\\tcurrent_line_prob.append( 0.95 )\\n\\t\\t\\t# Check for new lines\\n\\t\\t\\tif symbol.property.detected_break.type in [ breaks.EOL_SURE_SPACE, breaks.HYPHEN, breaks.LINE_BREAK ]:\\n\\t\\t\\t\\tline_box_list.append( [x1, y1, x2, y2] )\\n\\t\\t\\t\\tline_text_list.append( current_line_text )\\n\\t\\t\\t\\tline_prob_list.append( current_line_prob )\\n\\t\\t\\t\\t# Line under processing\\n\\t\\t\\t\\tcurrent_line_text = []\\n\\t\\t\\t\\tcurrent_line_prob = []\\n\\t\\t\\t\\t# Bounding box temporary variables\\n\\t\\t\\t\\tx1 = 100000\\n\\t\\t\\t\\ty1 = 100000\\n\\t\\t\\t\\tx2 = 0\\n\\t\\t\\t\\ty2 = 0\\n\\n\\treturn( line_box_list, line_text_list, line_prob_list )\",\n \"def print_paragraph(msg):\\n print\\n print \\\"\\\\n\\\".join(textwrap.wrap(msg, width=80))\",\n \"def test_reformat_paragraph_paragraph_1_of_3(self):\\n before_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe weather-prone country on Earth. Each year, Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000 tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly weather impacts every American. Communities can now rely on the National Weather Service’s StormReady program to help them guard against the ravages of Mother Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading to around 500 deaths per year and nearly $14 billion in damage. StormReady, a program started in 1999 in Tulsa, OK, helps arm America's communities with the communication and safety skills needed to save lives and property– before and during the event. StormReady helps community leaders and emergency managers strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of severe weather through better planning, education, and awareness. No community is storm proof, but StormReady can help communities save lives. Does StormReady make a difference?\\n\\n Last paragraph.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe\\n weather-prone country on Earth. Each\\n year, Americans cope with an average of\\n 10,000 thunderstorms, 2,500 floods,\\n 1,000 tornadoes, as well as an average\\n of 6 deadly hurricanes. Potentially\\n deadly weather impacts every American.\\n Communities can now rely on the National\\n Weather Service’s StormReady program to\\n help them guard against the ravages of\\n Mother Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading to around 500 deaths per year and nearly $14 billion in damage. StormReady, a program started in 1999 in Tulsa, OK, helps arm America's communities with the communication and safety skills needed to save lives and property– before and during the event. StormReady helps community leaders and emergency managers strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of severe weather through better planning, education, and awareness. No community is storm proof, but StormReady can help communities save lives. Does StormReady make a difference?\\n\\n Last paragraph.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"1.0\\\"),\\n after_sel=(\\\"13.0\\\", \\\"13.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def generate_new_book(text):\\n\\n for paragraph in text:\\n for sentence in paragraph:\\n for word in sentence:\\n print(word, end=' ')\\n print()\\n print()\",\n \"def test_with_preceding_text(self):\\n\\n expected = r'''\\n <p>foo\\n <strong>foo</strong></p>\\n <details class=\\\"note\\\">\\n <summary>Details</summary>\\n </details>\\n '''\\n\\n self.check_markdown(\\n R'''\\n foo\\n **foo**\\n ??? note \\\"Details\\\"\\n ''',\\n expected,\\n True\\n )\",\n \"def preprocess_reference_text(text):\\n try:\\n splitpoint = text.lower().rindex('reference')\\n except ValueError:\\n splitpoint = False\\n while splitpoint and len(text) - splitpoint < 100 and 'reference' in text[:splitpoint].lower():\\n text = text[:splitpoint]\\n splitpoint = text.lower().rindex('reference')\\n if not splitpoint:\\n has_reference_section = False\\n non_reference_section, reference_section = text, ''\\n else:\\n has_reference_section = True\\n non_reference_section, reference_section = text[:splitpoint], text[splitpoint:]\\n return has_reference_section, reference_section, non_reference_section\",\n \"def findFootnotesPlaceholder(self, root):\\n def finder(element):\\n for child in element:\\n if child.text:\\n if child.text.find(self.getConfig(\\\"PLACE_MARKER\\\")) > -1:\\n return child, element, True\\n if child.tail:\\n if child.tail.find(self.getConfig(\\\"PLACE_MARKER\\\")) > -1:\\n return child, element, False\\n finder(child)\\n return None\\n \\n res = finder(root)\\n return res\",\n \"def test_reformat_paragraph_paragraph_2_of_3(self):\\n before_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe\\n weather-prone country on Earth. Each\\n year, Americans cope with an average of\\n 10,000 thunderstorms, 2,500 floods,\\n 1,000 tornadoes, as well as an average\\n of 6 deadly hurricanes. Potentially\\n deadly weather impacts every American.\\n Communities can now rely on the National\\n Weather Service’s StormReady program to\\n help them guard against the ravages of\\n Mother Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading to around 500 deaths per year and nearly $14 billion in damage. StormReady, a program started in 1999 in Tulsa, OK, helps arm America's communities with the communication and safety skills needed to save lives and property– before and during the event. StormReady helps community leaders and emergency managers strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of severe weather through better planning, education, and awareness. No community is storm proof, but StormReady can help communities save lives. Does StormReady make a difference?\\n\\n Last paragraph.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe\\n weather-prone country on Earth. Each\\n year, Americans cope with an average of\\n 10,000 thunderstorms, 2,500 floods,\\n 1,000 tornadoes, as well as an average\\n of 6 deadly hurricanes. Potentially\\n deadly weather impacts every American.\\n Communities can now rely on the National\\n Weather Service’s StormReady program to\\n help them guard against the ravages of\\n Mother Nature.\\n\\n Some 90% of all presidentially declared\\n disasters are weather related, leading\\n to around 500 deaths per year and nearly\\n $14 billion in damage. StormReady, a\\n program started in 1999 in Tulsa, OK,\\n helps arm America's communities with the\\n communication and safety skills needed\\n to save lives and property– before and\\n during the event. StormReady helps\\n community leaders and emergency managers\\n strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of severe weather through better planning, education, and awareness. No community is storm proof, but StormReady can help communities save lives. Does StormReady make a difference?\\n\\n Last paragraph.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"13.0\\\", \\\"13.0\\\"),\\n after_sel=(\\\"25.0\\\", \\\"25.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def find_bound_paragraph(c: Cmdr) -> tuple[str, list[str], str]:\\n head, ins, tail = c.frame.body.getInsertLines()\\n head_lines = g.splitLines(head)\\n tail_lines = g.splitLines(tail)\\n result = []\\n insert_lines = g.splitLines(ins)\\n para_lines = insert_lines + tail_lines\\n # If the present line doesn't start a paragraph,\\n # scan backward, adding trailing lines of head to ins.\\n if insert_lines and not startsParagraph(insert_lines[0]):\\n n = 0 # number of moved lines.\\n for s in reversed(head_lines):\\n if ends_paragraph(s) or single_line_paragraph(s):\\n break\\n elif startsParagraph(s):\\n n += 1\\n break\\n else:\\n n += 1\\n if n > 0:\\n para_lines = head_lines[-n :] + para_lines\\n head_lines = head_lines[: -n]\\n ended, started = False, False\\n for i, s in enumerate(para_lines):\\n if started:\\n if ends_paragraph(s) or startsParagraph(s):\\n ended = True\\n break\\n else:\\n result.append(s)\\n elif s.strip():\\n result.append(s)\\n started = True\\n if ends_paragraph(s) or single_line_paragraph(s):\\n i += 1\\n ended = True\\n break\\n else:\\n head_lines.append(s)\\n if started:\\n head = ''.join(head_lines)\\n tail_lines = para_lines[i:] if ended else []\\n tail = ''.join(tail_lines)\\n return head, result, tail # string, list, string\\n return None, None, None\",\n \"def _get_next_textoutputsections(\\n sections: List[\\\"Section\\\"], index: int\\n) -> Iterator[\\\"Section\\\"]:\\n for j in range(index, len(sections)):\\n section = sections[j]\\n if section.directive == SphinxDoctestDirectives.TESTOUTPUT:\\n yield section\\n else:\\n break\",\n \"def parse_text(self):\\n text = self.get_data()\\n line1 = text[0]\\n index_list = [0]\\n start_index = 3\\n for i in range(1, len(text)):\\n\\n if line1.startswith('*'):\\n index_list, start_index = self.star_parser(index_list, line1)\\n elif line1.startswith('.'):\\n start_index = self.dot_parser(start_index, line1, text, i)\\n else:\\n print \\\"\\\".rjust(start_index) + line1\\n line1 = text[i]\\n # Parse the last line\\n if text[-1].startswith('*'):\\n self.star_parser(index_list, text[-1])\\n elif text[-1].startswith('.'):\\n print '-'.rjust(start_index) + text[-1].lstrip('.')\\n else:\\n print \\\"\\\".rjust(start_index) + text[-1]\",\n \"def onMnemoToMain(self):\\n self.second_main_text.SetFocus()\",\n \"def goToNextLink(idx):\\n eel.showLoader()\\n nextlink = wikiPageStackTrace[-1].getRawList()[idx].get('href')\\n url = baseArticleUrl+nextlink\\n print(\\\"going to \\\", url)\\n newpage = wikipediaPage(url)\\n wikiPageStackTrace.append(newpage)\\n titleStackTrace.append(newpage.getTitle())\\n urlStackTrace.append(newpage.getUrl())\\n update()\",\n \"def test_kill_paragraph(self):\\n before_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe weather-prone country on Earth. Each year,\\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\\n weather impacts every American. Communities can now rely on the National Weather\\n Service’s StormReady program to help them guard against the ravages of Mother\\n Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading\\n to around 500 deaths per year and nearly $14 billion in damage. StormReady, a\\n program started in 1999 in Tulsa, OK, helps arm America's communities with the\\n communication and safety skills needed to save lives and property– before and\\n during the event. StormReady helps community leaders and emergency managers\\n strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of\\n severe weather through better planning, education, and awareness. No community\\n is storm proof, but StormReady can help communities save lives. Does StormReady\\n make a difference?\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe weather-prone country on Earth. Each year,\\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\\n weather impacts every American. Communities can now rely on the National Weather\\n Service’s StormReady program to help them guard against the ravages of Mother\\n Nature.\\n\\n\\n\\n StormReady communities are better prepared to save lives from the onslaught of\\n severe weather through better planning, education, and awareness. No community\\n is storm proof, but StormReady can help communities save lives. Does StormReady\\n make a difference?\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"9.0\\\", \\\"9.0\\\"),\\n after_sel=(\\\"8.0\\\", \\\"8.0\\\"),\\n command_name=\\\"kill-paragraph\\\",\\n )\",\n \"def textinterpret(self,\\r\\n phrase,\\r\\n depth=0,\\r\\n re_entering=False,\\r\\n newindex=Index(-1)):\\r\\n\\r\\n if len(phrase) > 3:\\r\\n if phrase[0] == LEFTNOTE and phrase[-1] == RIGHTNOTE and len(phrase) > 1:\\r\\n phrase = phrase[1:-1]\\r\\n #eliminate enclosing brackets\\r\\n keylist = self.pass_key_dict[depth][0]\\r\\n addedlist = self.pass_key_dict[depth][1]\\r\\n #list to keep track of new key words added on\\r\\n\\r\\n if phrase[0] == ATSIGN:\\r\\n # at sign signs enclose an index\\r\\n right_at = True\\r\\n as_child = False\\r\\n index_phrase = phrase.split(ATSIGN)[1]\\r\\n index = Index(index_phrase)\\r\\n\\r\\n phrase = phrase.replace(ATSIGN+index_phrase+ATSIGN, EMPTYCHAR)\\r\\n # eliminates index phrase\\r\\n\\r\\n elif phrase[0] == PERCENTAGE:\\r\\n # percentage signs enclose a child index\\r\\n right_at = True\\r\\n as_child = True\\r\\n index_phrase = phrase.split(PERCENTAGE)[1]\\r\\n index = Index(index_phrase)\\r\\n\\r\\n phrase = phrase.replace(PERCENTAGE+index_phrase+PERCENTAGE, EMPTYCHAR)\\r\\n #eliminates index phrase\\r\\n\\r\\n elif phrase[0] == '\\\"':\\r\\n #for a child note\\r\\n phrase = phrase[1:]\\r\\n\\r\\n right_at = False\\r\\n as_child = True\\r\\n as_next = False\\r\\n\\r\\n index = self.index_sort([Index(0)]\\r\\n +[a_temp for a_temp\\r\\n in self.find_within(Index(0),\\r\\n Index(1),\\r\\n orequal=False)],\\r\\n by_date=False,\\r\\n quick=False)[-1]\\r\\n\\r\\n elif phrase[0] == \\\"'\\\":\\r\\n #for a next note\\r\\n\\r\\n phrase = phrase[1:]\\r\\n as_next = True\\r\\n as_child = False\\r\\n right_at = True\\r\\n index = self.index_sort([Index(0)]+[a_temp for a_temp\\r\\n in self.find_within(Index(0),\\r\\n Index(1),\\r\\n orequal=False)],\\r\\n by_date=False,\\r\\n quick=False)[-1]\\r\\n\\r\\n elif phrase[0] == \\\";\\\":\\r\\n # to go back to the previous level and add a next note\\r\\n phrase = phrase[1:]\\r\\n as_next = True\\r\\n as_child = False\\r\\n right_at = True\\r\\n index = self.index_sort([Index(0)]\\r\\n +[a_temp for a_temp\\r\\n in self.find_within(Index(0),\\r\\n Index(1),\\r\\n orequal=False)],\\r\\n by_date=False,\\r\\n quick=False)[-1]\\r\\n index = Index(index)\\r\\n index = index.previous()\\r\\n# index = str(index)\\r\\n\\r\\n\\r\\n elif phrase[0] not in [DOLLAR, DASH, PLUS, STAR]:\\r\\n # for an ordinary note\\r\\n\\r\\n j_temp = Index(int(Index(self.indexes()[-1])))\\r\\n # Procedure for moving notes out of the ZERO range\\r\\n for i_temp in self.find_within(Index(0), Index(1)):\\r\\n # j_temp is the next integer index\\r\\n self.move(i_temp, j_temp+Index(i_temp))\\r\\n\\r\\n right_at = False\\r\\n as_child = False\\r\\n as_next = False\\r\\n index = Index(0)\\r\\n\\r\\n if phrase[0] == DOLLAR:\\r\\n #new keyword set\\r\\n keylist = []\\r\\n if len(phrase) > 1:\\r\\n keylist += phrase[1:].split(COMMA)\\r\\n elif phrase[0] == PLUS:\\r\\n #add keyword set to existing\\r\\n if len(phrase) > 1:\\r\\n for k_temp in phrase[1:].split(COMMA):\\r\\n keylist.append(k_temp)\\r\\n addedlist.append(len(phrase[1:].split(COMMA)))\\r\\n\\r\\n elif phrase[0] == DASH:\\r\\n #delete keyword\\r\\n if addedlist and len(keylist) > addedlist[-1]:\\r\\n for a_temp in range(1, addedlist[-1]+1):\\r\\n keylist.pop()\\r\\n addedlist.pop()\\r\\n\\r\\n elif phrase[0] == STAR:\\r\\n #adds a single note with new keys,\\r\\n #yet without erasing the old keyset.\\r\\n # NEED TO CHECK IF THIS FUNCTION WORKS\\r\\n\\r\\n ks_temp = set(phrase[1:].split(SEMICOLON)[0].split(COMMA))\\r\\n ks_temp.update(extract.extract(phrase.split(SEMICOLON, 1)[1],\\r\\n LEFTCURLY,\\r\\n RIGHTCURLY))\\r\\n newindex = self.addnew(ks_temp,\\r\\n phrase.split(SEMICOLON, 1)[1])\\r\\n else:\\r\\n\\r\\n if not flatten.isflat(keylist):\\r\\n keylist = flatten.flatten(keylist)\\r\\n ks_temp = set(keylist)\\r\\n meta = {}\\r\\n if LEFTCURLY in phrase:\\r\\n ks_temp.update(extract.extract(phrase,\\r\\n LEFTCURLY,\\r\\n RIGHTCURLY))\\r\\n # extracts keywords that are enclosed\\r\\n #in curly brackets within the text\\r\\n if '^:' in phrase:\\r\\n metadatalist = extract.extract(phrase, '^:', ':^')\\r\\n # extract metadata\\r\\n\\r\\n for md_temp in metadatalist:\\r\\n #assigns metadata\\r\\n if VERTLINE in md_temp and len(md_temp.split(VERTLINE)) >= 2:\\r\\n if md_temp.split(VERTLINE)[1] == 'S':\\r\\n meta[md_temp.split(VERTLINE)[0]] = str(md_temp.split(VERTLINE)[2])\\\\\\r\\n .replace('\\\"'+\\\"'\\\",\\\"'\\\")\\\\\\r\\n .replace(\\\"'\\\"+'\\\"',\\\"'\\\")\\r\\n if md_temp.split(VERTLINE)[1] == 'I':\\r\\n meta[md_temp.split(VERTLINE)[0]] = int(md_temp.split(VERTLINE)[2])\\r\\n if md_temp.split(VERTLINE)[1] == 'L':\\r\\n meta[md_temp.split(VERTLINE)[0]] = [x_temp.replace('\\\"'+\\\"'\\\",\\\"'\\\")\\\\\\r\\n .replace(\\\"'\\\"+'\\\"',\\\"'\\\") for x_temp in\\r\\n md_temp.split(VERTLINE)[2][1:-1].split(COMMA)]\\r\\n phrase = nformat.remove_between(phrase, '^:', ':^')\\r\\n newindex = self.enter(ks_temp,\\r\\n phrase,\\r\\n meta,\\r\\n query=False,\\r\\n not_parsing=False,\\r\\n right_at=right_at,\\r\\n as_child=as_child,\\r\\n ind=str(index),\\r\\n re_entering=re_entering)\\r\\n self.pass_key_dict[depth][0] = keylist\\r\\n self.pass_key_dict[depth][1] = addedlist\\r\\n return newindex\",\n \"def split_description_into_paragraphs(unformatted_description):\\n description = unformatted_description.strip()\\n paragraphs = re.compile(r'[\\\\n\\\\r]{2,}').split(description)\\n formatted_paragraphs = []\\n\\n # Sanitise paragraphs\\n def external(attrs, new=False):\\n url_parts = urlparse(attrs[(None, \\\"href\\\")])\\n if url_parts.netloc and url_parts.netloc != 'snapcraft.io':\\n if (None, \\\"class\\\") not in attrs:\\n attrs[(None, \\\"class\\\")] = \\\"p-link--external\\\"\\n elif \\\"p-link--external\\\" not in attrs[(None, \\\"class\\\")]:\\n attrs[(None, \\\"class\\\")] += \\\" p-link--external\\\"\\n return attrs\\n\\n for paragraph in paragraphs:\\n callbacks = bleach.linkifier.DEFAULT_CALLBACKS\\n callbacks.append(external)\\n\\n paragraph = bleach.clean(paragraph, tags=[])\\n paragraph = bleach.linkify(paragraph, callbacks=callbacks)\\n\\n formatted_paragraphs.append(paragraph.replace('\\\\n', '<br />'))\\n\\n return formatted_paragraphs\",\n \"def test_reformat_paragraph_paragraph_3_of_3(self):\\n before_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe\\n weather-prone country on Earth. Each\\n year, Americans cope with an average of\\n 10,000 thunderstorms, 2,500 floods,\\n 1,000 tornadoes, as well as an average\\n of 6 deadly hurricanes. Potentially\\n deadly weather impacts every American.\\n Communities can now rely on the National\\n Weather Service’s StormReady program to\\n help them guard against the ravages of\\n Mother Nature.\\n\\n Some 90% of all presidentially declared\\n disasters are weather related, leading\\n to around 500 deaths per year and nearly\\n $14 billion in damage. StormReady, a\\n program started in 1999 in Tulsa, OK,\\n helps arm America's communities with the\\n communication and safety skills needed\\n to save lives and property– before and\\n during the event. StormReady helps\\n community leaders and emergency managers\\n strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of severe weather through better planning, education, and awareness. No community is storm proof, but StormReady can help communities save lives. Does StormReady make a difference?\\n\\n Last paragraph.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe\\n weather-prone country on Earth. Each\\n year, Americans cope with an average of\\n 10,000 thunderstorms, 2,500 floods,\\n 1,000 tornadoes, as well as an average\\n of 6 deadly hurricanes. Potentially\\n deadly weather impacts every American.\\n Communities can now rely on the National\\n Weather Service’s StormReady program to\\n help them guard against the ravages of\\n Mother Nature.\\n\\n Some 90% of all presidentially declared\\n disasters are weather related, leading\\n to around 500 deaths per year and nearly\\n $14 billion in damage. StormReady, a\\n program started in 1999 in Tulsa, OK,\\n helps arm America's communities with the\\n communication and safety skills needed\\n to save lives and property– before and\\n during the event. StormReady helps\\n community leaders and emergency managers\\n strengthen local safety programs.\\n\\n StormReady communities are better\\n prepared to save lives from the\\n onslaught of severe weather through\\n better planning, education, and\\n awareness. No community is storm proof,\\n but StormReady can help communities save\\n lives. Does StormReady make a\\n difference?\\n\\n Last paragraph.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"25.10\\\", \\\"25.10\\\"),\\n after_sel=(\\\"34.0\\\", \\\"34.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def test_reformat_paragraph_new_code_4_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n - Point 1. xxxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 11.\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n - Point 1. xxxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 11.\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"1.0\\\"),\\n after_sel=(\\\"3.0\\\", \\\"3.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def footnote_spot(tree: nodes.document) -> tuple[Element, int]:\\n # The code uses the following heuristic:\\n # a) place them after the last existing footnote\\n # b) place them after an (empty) Footnotes rubric\\n # c) create an empty Footnotes rubric at the end of the document\\n fns = list(tree.findall(nodes.footnote))\\n if fns:\\n fn = fns[-1]\\n return fn.parent, fn.parent.index(fn) + 1\\n for node in tree.findall(nodes.rubric):\\n if len(node) == 1 and node.astext() == FOOTNOTES_RUBRIC_NAME:\\n return node.parent, node.parent.index(node) + 1\\n doc = next(tree.findall(nodes.document))\\n rub = nodes.rubric()\\n rub.append(nodes.Text(FOOTNOTES_RUBRIC_NAME))\\n doc.append(rub)\\n return doc, doc.index(rub) + 1\",\n \"def test_getPassage_prevnext(self):\\n passage = self.resolver.getTextualNode(\\n \\\"urn:cts:latinLit:phi1294.phi002.perseus-lat2\\\", subreference=\\\"1.1\\\", metadata=True\\n )\\n\\n self.assertIsInstance(\\n passage, Passage,\\n \\\"GetPassage should always return passages objects\\\"\\n )\\n self.assertEqual(\\n passage.prevId, \\\"1.pr\\\",\\n \\\"Previous Passage ID should be parsed\\\"\\n )\\n self.assertEqual(\\n passage.nextId, \\\"1.2\\\",\\n \\\"Next Passage ID should be parsed\\\"\\n )\\n\\n children = list(passage.getReffs())\\n # Ensure navigability\\n self.assertIn(\\n \\\"verentia ludant; quae adeo antiquis auctoribus defuit, ut\\\",\\n passage.prev.export(output=Mimetypes.PLAINTEXT),\\n \\\"Left and Right Navigation should be available\\\"\\n )\\n self.assertIn(\\n \\\"Qui tecum cupis esse meos ubicumque libellos \\\",\\n passage.next.export(output=Mimetypes.PLAINTEXT),\\n \\\"Left and Right Navigation should be available\\\"\\n )\\n\\n # We check the passage is able to perform further requests and is well instantiated\\n self.assertEqual(\\n children[0], '1.1.1',\\n \\\"Resource should be string identifiers\\\"\\n )\\n\\n self.assertIn(\\n \\\"Hic est quem legis ille, quem requiris,\\\", passage.export(output=Mimetypes.PLAINTEXT),\\n \\\"Export PrototypeText should work correctly\\\"\\n )\\n\\n self.assertEqual(\\n passage.export(output=Mimetypes.PYTHON.ETREE).xpath(\\\".//tei:l[@n='1']/text()\\\", namespaces=NS, magic_string=False),\\n [\\\"Hic est quem legis ille, quem requiris, \\\"],\\n \\\"Export to Etree should give an Etree or Etree like object\\\"\\n )\",\n \"def placeNoteLists(self, text):\\n if self.notes:\\n o = OrderedDict()\\n for label, info in self.notes.items():\\n if 'seq' in info:\\n i = info['seq']\\n info['seq'] = label\\n o[i] = info\\n else:\\n self.unreferencedNotes[label] = info\\n\\n if o:\\n # sort o by key\\n o = OrderedDict(sorted(o.items(), key=lambda t: t[0]))\\n self.notes = o\\n text_re = re.compile('<p>notelist(%s)(?:\\\\:([\\\\w|%s]))?([\\\\^!]?)(\\\\+?)\\\\.?[\\\\s]*</p>'\\n % (self.c, self.syms), re.U)\\n text = text_re.sub(self.fNoteLists, text)\\n return text\",\n \"def test_reformat_paragraph_new_code_7_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 32.\\n\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 41.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 32.\\n\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 41.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"2.11\\\", \\\"2.11\\\"),\\n after_sel=(\\\"3.1\\\", \\\"3.1\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def main():\\n\\n parser = argparse.ArgumentParser(description=\\\"Prints the contents of a NiPoPoW\\\")\\n parser.add_argument(\\\"--blocks\\\", required=True, type=int, help=\\\"Number of blocks\\\")\\n parser.add_argument(\\n \\\"--output\\\", default=\\\"proof.pkl\\\", type=str, help=\\\"Name of exported proof\\\"\\n )\\n args = parser.parse_args()\\n blocks = args.blocks\\n output = args.output\\n if output.find(\\\".pkl\\\") == -1:\\n output += \\\".pkl\\\"\\n\\n # Create blockchain\\n header, headers_map, interlink_map = create_blockchain(blocks=blocks)\\n print_headers(headers_map)\\n print_interlinks(headers_map, interlink_map)\\n\\n # Create proof\\n proof = make_proof(header, headers_map, interlink_map)\\n print_proof(proof, headers_map)\\n\\n ### Start spoiling proof\\n\\n # remove_genesis(proof)\\n # proof = change_interlink_hash(proof, 0)\\n # proof = skip_blocks(proof, -2)\\n # proof = replace_block(proof, headers_map, interlink_map, int(len(proof)/2))\\n # print_proof(proof, headers_map)\\n # verify_proof(Hash(proof[0][0]), proof)\\n\\n ### Stop spoiling proof\\n\\n proof_tool = ProofTool(\\\"../../data/proofs/\\\")\\n p, f, lca = proof_tool.create_proof_and_forkproof(blocks, forkindex, forkblocks)\\n print(p, f, lca)\\n\\n fixed_fork_proof = proof_tool.fetch_proof(f)\\n verify_proof(Hash(fixed_fork_proof[0][0]), fixed_fork_proof)\\n\\n # proof_tool = ProofTool(\\\"../../data/proofs/\\\")\\n # proof_tool.export_proof(fixed_fork_proof, f)\",\n \"def process_labels(ctx, tex, chapter):\\n headings = ['chapter'] + ['sub'*i + 'section' for i in range(4)]\\n reh = r'(' + '|'.join(headings) + r'){(.+?)}'\\n environments = ['thm', 'lem', 'exc', 'figure', 'equation']\\n ree = r'begin{(' + '|'.join(environments) + r')}'\\n rel = r'(\\\\w+)label{(.+?)}'\\n rel2 = r'label{(.+?)}'\\n bigone = r'\\\\\\\\({})|\\\\\\\\({})|\\\\\\\\({})|\\\\\\\\(caption)|\\\\\\\\({})'.format(reh, ree, rel, rel2)\\n rx = re.compile(bigone)\\n\\n sec_ctr = [chapter] + [0]*(len(headings))\\n env_ctr = [0]*len(environments)\\n blocks = catlist()\\n lastlabel = None\\n lastidx = 0\\n m = rx.search(tex, lastidx)\\n while m:\\n blocks.append(tex[lastidx:m.start()])\\n lastidx = m.start()\\n cmd = next_command(tex, lastidx)\\n lastidx = cmd.end\\n if m.group(2):\\n # This is a sectioning command (chapter, subsection,...)\\n name = m.group(2)\\n i = headings.index(name)\\n if i == 0:\\n env_ctr = [0]*len(env_ctr)\\n sec_ctr[i:] = [sec_ctr[i]+1]+[0]*(len(headings)-i-1)\\n number = \\\".\\\".join([str(x) for x in sec_ctr[:i+1]])\\n idd = \\\"{}:{}\\\".format(name, number)\\n lastlabel = idd\\n blocks.append(\\\"<a id='{}'></a>\\\".format(idd))\\n\\n title = '{} {}'.format(number, cmd.args[0])\\n blocks.append(r'\\\\{}{{{}}}'.format(name, title))\\n\\n elif m.group(5):\\n # This is an environment (thm, lem, ...)\\n name = m.group(5)\\n lastenv = name # save this for a caption command coming later...\\n i = environments.index(name)\\n env_ctr[i] += 1\\n number = \\\"{}.{}\\\".format(sec_ctr[0], env_ctr[i])\\n idd = \\\"{}:{}\\\".format(name, number)\\n lastlabel = idd\\n blocks.append(\\\"<a id='{}'></a>\\\".format(idd))\\n\\n if name in ctx.theoremlike_environments:\\n nicename = ctx.named_entities[name]\\n title = '{} {}'.format(nicename, number)\\n blocks.append(r'\\\\begin{{{}}}[{}]'.format(name, title))\\n else:\\n blocks.append(r'\\\\begin{{{}}}'.format(name))\\n\\n elif m.group(6):\\n # This is a labelling command (\\\\thmlabel, \\\\seclabel,...)\\n label = \\\"{}:{}\\\".format(m.group(7), m.group(8))\\n ctx.label_map[label] = (ctx.outputfile, lastlabel)\\n\\n elif m.group(9):\\n # This is a caption command\\n name = lastenv\\n i = environments.index(name)\\n number = \\\"{}.{}\\\".format(sec_ctr[0], env_ctr[i])\\n idd = \\\"{}:{}\\\".format(name, number)\\n lastlabel = idd\\n nicename = ctx.named_entities[name]\\n title = '<span class=\\\"title\\\">{} {}</span>'.format(nicename, number)\\n text = '{} {}'.format(title, cmd.args[0])\\n blocks.append(r'\\\\caption{{{}}}'.format(text))\\n\\n elif m.group(10):\\n # This is a \\\\label command, probably the target of a pageref\\n idd = gen_unique_id()\\n blocks.append(\\\"<a id={}></a>\\\".format(idd))\\n ctx.label_map[m.group(11)] = (ctx.outputfile, idd)\\n\\n m = rx.search(tex, lastidx)\\n blocks.append(tex[lastidx:])\\n return \\\"\\\".join(blocks)\",\n \"def snippetyielder(filename):\\n\\ttext = open(filename, \\\"r\\\")\\n\\ta = text.readlines()\\n\\tp = \\\"\\\".join(a) \\t #detecting the breaks between documents and identifying them to break the docs with\\n\\n\\n\\tdocbreak = re.sub(r\\\".*([1\\\\?RU]+[ce][j~p]+o[rtd\\\\*]+ .[2Jf].*)\\\",r\\\"DOCBREAK \\\\1\\\",p)\\n\\tdocbreak = re.sub(r\\\"(.*[lL]ett.*fro[mn].*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Petition .f.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Order o[/f].*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(General order of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Special order of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Unofficial letter of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Letter of .*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*([\\\\[I\\\\]]\\\\s*T[cue]legram.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(\\\\[Enclosure.+\\\\].*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Extracts* from .*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(A[hb]stract[of ]*log.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Instructions from.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(A[hb]stract of statement.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Instructions* of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Memorandum from.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*([llifM]+emorandum of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Communication from.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Statement of circumstances.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Further report of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Second report of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Additional report of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Detailed repor[~t] of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(General report of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\tdocbreak = re.sub(r\\\".*(Deposition of.*)\\\",r\\\"DOCBREAK \\\\1\\\",docbreak)\\n\\t# docbreak = re.sub(r\\\"(DOCBREAK)+\\\",r\\\"DOCBREAK\\\\n\\\",docbreak) \\t\\n\\tdocbreaks = docbreak.split(\\\"DOCBREAK\\\") \\t #yielding one document at a time\\n\\tfor doc in docbreaks:\\n\\t\\tif re.search(r\\\".+\\\",doc): \\t\\n\\t\\t\\tyield doc\",\n \"def footnotes(self, text):\\n html = '<div class=\\\"footnotes\\\">\\\\n%s<ol>%s</ol>\\\\n</div>\\\\n'\\n return html % (self.hrule(), text)\",\n \"def navigation(self):\\r\\n text_from_xml, ids, eng_list = self.util.get_text_from_xml(self.string_xml, \\\"Navigation\\\", \\\"trans-unit\\\",\\r\\n Config.selected_language.strip())\\r\\n xpath = self.util.read_xpath_list_from_xml(self.object_repo, \\\"Navigation\\\", self.my_object)\\r\\n lenth = len(xpath)\\r\\n text_index = 0\\r\\n loop_index = 0\\r\\n while loop_index < lenth:\\r\\n if xpath[loop_index]['xpath'] == 'click':\\r\\n # self.util.client.sleep(2000)\\r\\n self.object.click(self.util.client, xpath[loop_index + 1]['zone'],\\r\\n xpath[loop_index + 1]['xpath'],\\r\\n xpath[loop_index + 1]['index'],\\r\\n xpath[loop_index + 1]['comment'],\\r\\n 1, self.logger_name)\\r\\n loop_index += 2\\r\\n continue\\r\\n if xpath[loop_index]['xpath'] == 'place':\\r\\n # self.place_holder(xpath,loop_index+1,actual_text,text_index)\\r\\n text_index += 1\\r\\n loop_index += 2\\r\\n continue\\r\\n self.get_text_compare(xpath, loop_index, text_from_xml, text_index, ids, eng_list)\\r\\n text_index += 1\\r\\n loop_index += 1\",\n \"def open(self, p):\\n p.open()\\n for s in self.surround(p):\\n point = self.search(s[0], s[1])\\n if point.is_bomb():\\n continue\\n if point.open():\\n self.open(point)\",\n \"def treat_new_line(self,text):\\n text=text.replace('.\\\\n','. ')\\n text=re.sub(r'(\\\\n\\\\s*)+\\\\n+', '\\\\n\\\\n',text )\\n \\n lw=text.split('\\\\n\\\\n')\\n lw=[c for c in lw if c.replace(' ','')!='']\\n \\n for i in range(1,len(lw)):\\n try:\\n\\n el=lw[i]\\n if len(el)>=1:\\n try:\\n first_w=el.split()[0]\\n except:\\n first_w=el\\n first_l=first_w[0]\\n if first_l.isupper() :\\n if len(lw[i-1])>0 and lw[i-1].replace(' ','') !='':\\n if lw[i-1].replace(' ','')[-1] not in [\\\":\\\",'.',\\\"-\\\",'/',\\\"'\\\",\\\";\\\"]:\\n prec=lw[i-1].split(\\\".\\\")[-1]\\n merge=(prec+' '+lw[i]).split()\\n dic=dict(nltk.tag.pos_tag(merge))\\n proper_noun=dic[first_w]=='NNP'\\n if not proper_noun:\\n if not \\\".\\\" in lw[i-1]:\\n lw[i-1]=lw[i-1]+\\\".\\\\n\\\\n \\\"\\n else:\\n lw[i-1]=lw[i-1][:-1]+\\\".\\\\n\\\\n \\\"\\n else:\\n lw[i-1]+=' '\\n\\n\\n elif first_l.islower():\\n if len(lw[i-1])>0 and lw[i-1][-1].replace(' ','')!='':\\n\\n if lw[i-1][-1].replace(' ','')[-1]!='-':\\n lw[i-1]+=\\\"\\\"\\n else:\\n\\n ltemp_prev=lw[i-1].split(' ')\\n ltemp_next=lw[i].split(' ')\\n motprev=ltemp_prev[-1][:-1]\\n motnext=lw[i].split(' ')[0]\\n if len((motprev+' '+motnext).split())==2:\\n\\n if self.english_voc.check(motprev) and self.english_voc.check(motnext) and not self.english_voc.check(\\\"\\\".join([motprev,motnext])) :\\n newmot=\\\" \\\".join([motprev,motnext])\\n else:\\n newmot=\\\"\\\".join([motprev,motnext])\\n ltemp_prev[-1]=newmot\\n ltemp_next[0]=\\\"\\\"\\n lw[i-1]=\\\" \\\".join(ltemp_prev)\\n lw[i]=\\\" \\\".join(ltemp_next)\\n else:\\n lw[i-1]+=\\\"\\\\n\\\\n\\\"\\n \\n except:\\n print('Error occurs, the reader may not be suitable for your pdf files')\\n \\n \\n text=\\\"\\\".join(lw)\\n \\n lw=text.split('\\\\n')\\n lw=[c for c in lw if c.replace(' ','')!='']\\n for i in range(1,len(lw)):\\n try:\\n el=lw[i]\\n if len(el)>=1:\\n try:\\n first_w=el.split()[0]\\n except:\\n first_w=el\\n first_l=first_w[0]\\n if first_l.isupper() :\\n if len(lw[i-1])>0 and lw[i-1].replace(' ','')!='':\\n if lw[i-1].replace(' ','')[-1] not in [\\\":\\\",'.',\\\"-\\\",'/',\\\"'\\\",\\\";\\\"]:\\n prec=lw[i-1].split(\\\".\\\")[-1]\\n merge=(prec+' '+lw[i]).split()\\n dic=dict(nltk.tag.pos_tag(merge))\\n proper_noun=dic[first_w]=='NNP'\\n if not proper_noun:\\n if not \\\".\\\" in lw[i-1]:\\n lw[i-1]=lw[i-1]+\\\".\\\\n\\\\n \\\"\\n else:\\n lw[i-1]=lw[i-1][:-1]+\\\".\\\\n\\\\n \\\"\\n else:\\n lw[i-1]+=' '\\n elif first_l.islower():\\n if len(lw[i-1])>0 and lw[i-1].replace(' ','')!='':\\n if lw[i-1].replace(' ','')[-1]==\\\"-\\\":\\n ltemp_prev=lw[i-1].split(' ')\\n ltemp_next=lw[i].split(' ')\\n motprev=ltemp_prev[-1][:-1]\\n motnext=lw[i].split(' ')[0]\\n if len((motprev+' '+motnext).split())==2:\\n if self.english_voc.check(motprev) and self.english_voc.check(motnext) and not self.english_voc.check(\\\"\\\".join([motprev,motnext])) :\\n newmot=\\\" \\\".join([motprev,motnext])\\n else:\\n newmot=\\\"\\\".join([motprev,motnext])\\n ltemp_prev[-1]=newmot\\n ltemp_next[0]=\\\"\\\"\\n lw[i-1]=\\\" \\\".join(ltemp_prev)\\n lw[i]=\\\" \\\".join(ltemp_next)\\n\\n\\n\\n else:\\n lw[i-1]+=\\\" \\\"\\n else:\\n lw[i-1]+=\\\" \\\"\\n \\n except:\\n print('Error occurs, the reader may not be suitable for your pdf files')\\n \\n text=\\\"\\\".join(lw)\\n return text\",\n \"def test_reformat_paragraph_list_1_of_5(self):\\n before_b = \\\"\\\"\\\"\\\\\\n This paragraph leads of this test. It is the \\\"lead\\\"\\n paragraph.\\n\\n 1. This is item \\n number 1. It is the first item in the list.\\n\\n 2. This is item \\n number 2. It is the second item in the list.\\n\\n 3. This is item \\n number 3. It is the third item in the list.\\n\\n This paragraph ends the test. It is the \\\"final\\\"\\n paragraph.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n This paragraph leads of this test. It is\\n the \\\"lead\\\" paragraph.\\n\\n 1. This is item \\n number 1. It is the first item in the list.\\n\\n 2. This is item \\n number 2. It is the second item in the list.\\n\\n 3. This is item \\n number 3. It is the third item in the list.\\n\\n This paragraph ends the test. It is the \\\"final\\\"\\n paragraph.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"1.0\\\"),\\n after_sel=(\\\"4.0\\\", \\\"4.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def display_text(target_text):\\n\\n print('Text to analyze:')\\n print('')\\n print('-------TEXT BELOW-------')\\n print(target_text)\\n print('-------TEXT ENDS-------')\\n print('')\",\n \"def test_reformat_paragraph_new_code_6_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 32.\\n\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 32.\\n\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"1.0\\\"),\\n after_sel=(\\\"4.0\\\", \\\"4.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def test_getPassage_metadata_prevnext(self):\\n passage = self.resolver.getTextualNode(\\n \\\"urn:cts:latinLit:phi1294.phi002.perseus-lat2\\\", subreference=\\\"1.1\\\", metadata=True, prevnext=True\\n )\\n self.assertIsInstance(\\n passage, Passage,\\n \\\"GetPassage should always return passages objects\\\"\\n )\\n self.assertEqual(\\n str(passage.metadata[NAMESPACES.CTS.term(\\\"title\\\"), \\\"eng\\\"]), \\\"Epigrammata\\\",\\n \\\"Local Inventory Files should be parsed and aggregated correctly\\\"\\n )\\n self.assertEqual(\\n str(passage.metadata[NAMESPACES.CTS.term(\\\"groupname\\\"), \\\"eng\\\"]), \\\"Martial\\\",\\n \\\"Local Inventory Files should be parsed and aggregated correctly\\\"\\n )\\n self.assertEqual(\\n str(passage.metadata[NAMESPACES.CTS.term(\\\"label\\\"), \\\"eng\\\"]), \\\"Epigrams\\\",\\n \\\"Local Inventory Files should be parsed and aggregated correctly\\\"\\n )\\n self.assertEqual(\\n str(passage.metadata[NAMESPACES.CTS.term(\\\"description\\\"), \\\"eng\\\"]),\\n \\\"M. Valerii Martialis Epigrammaton libri / recognovit W. Heraeus\\\",\\n \\\"Local Inventory Files should be parsed and aggregated correctly\\\"\\n )\\n self.assertEqual(\\n passage.citation.name, \\\"book\\\",\\n \\\"Local Inventory Files should be parsed and aggregated correctly\\\"\\n )\\n self.assertEqual(\\n len(passage.citation), 3,\\n \\\"Local Inventory Files should be parsed and aggregated correctly\\\"\\n )\\n self.assertEqual(\\n passage.prevId, \\\"1.pr\\\",\\n \\\"Previous Passage ID should be parsed\\\"\\n )\\n self.assertEqual(\\n passage.nextId, \\\"1.2\\\",\\n \\\"Next Passage ID should be parsed\\\"\\n )\\n children = list(passage.getReffs())\\n # Ensure navigability\\n self.assertIn(\\n \\\"verentia ludant; quae adeo antiquis auctoribus defuit, ut\\\",\\n passage.prev.export(output=Mimetypes.PLAINTEXT),\\n \\\"Left and Right Navigation should be available\\\"\\n )\\n self.assertIn(\\n \\\"Qui tecum cupis esse meos ubicumque libellos \\\",\\n passage.next.export(output=Mimetypes.PLAINTEXT),\\n \\\"Left and Right Navigation should be available\\\"\\n )\\n\\n # We check the passage is able to perform further requests and is well instantiated\\n self.assertEqual(\\n children[0], '1.1.1',\\n \\\"Resource should be string identifiers\\\"\\n )\\n\\n self.assertIn(\\n \\\"Hic est quem legis ille, quem requiris,\\\", passage.export(output=Mimetypes.PLAINTEXT),\\n \\\"Export PrototypeText should work correctly\\\"\\n )\\n\\n self.assertEqual(\\n passage.export(output=Mimetypes.PYTHON.ETREE).xpath(\\\".//tei:l[@n='1']/text()\\\", namespaces=NS, magic_string=False),\\n [\\\"Hic est quem legis ille, quem requiris, \\\"],\\n \\\"Export to Etree should give an Etree or Etree like object\\\"\\n )\",\n \"def get_first_link(self, article):\\n #Hit the article Wikipeadia URL\\n page = urllib.request.urlopen(article)\\n html = page.read()\\n soup = BeautifulSoup(html, 'lxml')\\n\\n #Iterate over all the paragraphs on that page to find the first valid link\\n for child_para in soup.find_all('p'):\\n links_para = str(re.findall('\\\\((.*?)\\\\)', str(child_para)))\\n if self.check_paragraph(child_para, links_para):\\n for child_link in child_para.find_all('a'):\\n if self.check_link(child_link, links_para):\\n #Return the next child link\\n return 'https://en.wikipedia.org' + child_link['href']\",\n \"def test_reformat_paragraph_new_code_5_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 22.\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 22.\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"2.0\\\"),\\n after_sel=(\\\"3.0\\\", \\\"3.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def __extract_text_and_hyp(self, line):\\n\\n line = unquote(line)\\n list_hyp = []\\n num_mentions = 0\\n start_entities = [m.start() for m in re.finditer('<a href=\\\"', line)]\\n end_entities = [m.start() for m in re.finditer('\\\">', line)]\\n end_mentions = [m.start() for m in re.finditer(\\\"</a>\\\", line)]\\n\\n disambiguation_ent_errors = 0\\n start_entity = line.find('<a href=\\\"')\\n\\n while start_entity >= 0:\\n line = line[start_entity + len('<a href=\\\"') :]\\n end_entity = line.find('\\\">')\\n end_mention = line.find(\\\"</a>\\\")\\n mention = line[end_entity + len('\\\">') : end_mention]\\n\\n if (\\n (\\\"Wikipedia\\\" not in mention)\\n and (\\\"wikipedia\\\" not in mention)\\n and (len(mention) >= 1)\\n ):\\n # Valid mention\\n entity = line[0:end_entity]\\n find_wikt = entity.find(\\\"wikt:\\\")\\n entity = entity[len(\\\"wikt:\\\") :] if find_wikt == 0 else entity\\n entity = self.wikipedia.preprocess_ent_name(entity)\\n\\n if entity.find(\\\"List of \\\") != 0:\\n if \\\"#\\\" not in entity:\\n ent_wiki_id = self.wikipedia.ent_wiki_id_from_name(entity)\\n if ent_wiki_id == -1:\\n disambiguation_ent_errors += 1\\n else:\\n num_mentions += 1\\n list_hyp.append(\\n {\\n \\\"mention\\\": mention,\\n \\\"ent_wikiid\\\": ent_wiki_id,\\n \\\"cnt\\\": num_mentions,\\n }\\n )\\n # find new entity\\n start_entity = line.find('<a href=\\\"')\\n return (\\n list_hyp,\\n disambiguation_ent_errors,\\n [len(start_entities), len(end_entities), len(end_mentions)],\\n )\",\n \"def go_to(self, value=None):\\n self.go_to_this_line = self.line_number.get()\\n self.my_text.mark_set(INSERT, str(float(self.go_to_this_line)))\\n self.current_area()\\n self.my_text.see(INSERT)\\n self.searcher.destroy()\",\n \"def test_extract_pdf_prev():\\n\\n test_pdf_path = 'tests/files/research/fea48178ffac3a42035ed27d6e2b897cb570cf13.pdf'\\n text = pdf_util.extract_pdf_text_prev(test_pdf_path)\\n\\n assert text\\n assert \\\"Yoshiyuki\\\" in text\",\n \"def split_paragraphs(block):\\n # Break block contents into paragraphs by blank lines.\\n def gen(block):\\n par = []\\n for obj in block:\\n if isinstance(obj, Text) and obj.empty:\\n # New paragraph.\\n yield par\\n par = []\\n else:\\n par.append(obj)\\n yield par\\n\\n # Combine paragraphs. \\n def finish(pars):\\n for par in pars:\\n if len(par) == 0:\\n continue\\n elif any( isinstance(o, Text) for o in par ):\\n # Paragraph contains text. Use a P element.\\n yield Block(par, tag='P')\\n else:\\n # Doesn't contain text; don't wrap it.\\n yield from par\\n\\n block[:] = finish(gen(block))\",\n \"def test_reformat_paragraph_list_3_of_5(self):\\n before_b = \\\"\\\"\\\"\\\\\\n This paragraph leads of this test. It is\\n the \\\"lead\\\" paragraph.\\n\\n 1. This is item number 1. It is the\\n first item in the list.\\n\\n 2. This is item \\n number 2. It is the second item in the list.\\n\\n 3. This is item \\n number 3. It is the third item in the list.\\n\\n This paragraph ends the test. It is the \\\"final\\\"\\n paragraph.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n This paragraph leads of this test. It is\\n the \\\"lead\\\" paragraph.\\n\\n 1. This is item number 1. It is the\\n first item in the list.\\n\\n 2. This is item number 2. It is the\\n second item in the list.\\n\\n 3. This is item \\n number 3. It is the third item in the list.\\n\\n This paragraph ends the test. It is the \\\"final\\\"\\n paragraph.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"7.0\\\", \\\"7.0\\\"),\\n after_sel=(\\\"10.0\\\", \\\"10.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def insert_paragraphs(self, str, ignore_pre=True):\\n for block in splittag(str, 'pre'):\\n if ignore_pre and '<pre>' in block:\\n self.insert_text(block)\\n if 'Holds down and then' in block:\\n print block\\n else:\\n self.insert_text('\\\\n'.join('<p>%s</p>' % line\\n for line in block.splitlines()))\",\n \"def do_p(self, line):\\n if not self.current:\\n print_table(self.get_profiles(), self.vertical_display)\",\n \"def _process_parse(parse, coreflist):\\n sentence = parse.get('sentences')\\n if sentence:\\n ptree = Tree.parse(tag_ptree(sentence[0]['parsetree'], coreflist))\\n words = [(w[0], w[1]) for w in sentence[0]['words']]\\n depends = [(d[0], d[1], d[2]) for d in sentence[0]['dependencies']]\\n text = sentence[0]['text']\\n\\n return ptree, words, depends, text\\n else:\\n return None\",\n \"def test_reformat_paragraph_list_2_of_5(self):\\n before_b = \\\"\\\"\\\"\\\\\\n This paragraph leads of this test. It is\\n the \\\"lead\\\" paragraph.\\n\\n 1. This is item number 1. It is the\\n first item in the list.\\n\\n 2. This is item \\n number 2. It is the second item in the list.\\n\\n 3. This is item \\n number 3. It is the third item in the list.\\n\\n This paragraph ends the test. It is the \\\"final\\\"\\n paragraph.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n This paragraph leads of this test. It is\\n the \\\"lead\\\" paragraph.\\n\\n 1. This is item number 1. It is the\\n first item in the list.\\n\\n 2. This is item \\n number 2. It is the second item in the list.\\n\\n 3. This is item \\n number 3. It is the third item in the list.\\n\\n This paragraph ends the test. It is the \\\"final\\\"\\n paragraph.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"4.0\\\", \\\"4.0\\\"),\\n after_sel=(\\\"7.0\\\", \\\"7.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def highlight_next_match(self):\\n self.text.tag_remove('found.focus', '1.0',\\n tk.END) # remove existing tag\\n try:\\n start, end = self.text.tag_nextrange('found', self.start, tk.END)\\n self.text.tag_add('found.focus', start, end)\\n self.text.mark_set(tk.INSERT, start)\\n self.text.see(start)\\n self.start = end\\n except ValueError:\\n if self.start != '1.0':\\n self.start = '1.0'\\n self.text.see('1.0')\\n self.highlight_next_match()\",\n \"def highlight_next_match(self):\\n self.text.tag_remove('found.focus', '1.0',\\n tk.END) # remove existing tag\\n try:\\n start, end = self.text.tag_nextrange('found', self.start, tk.END)\\n self.text.tag_add('found.focus', start, end)\\n self.text.mark_set(tk.INSERT, start)\\n self.text.see(start)\\n self.start = end\\n except ValueError:\\n if self.start != '1.0':\\n self.start = '1.0'\\n self.text.see('1.0')\\n self.highlight_next_match()\",\n \"def afterFlowable(self, flowable):\\n\\n if isinstance(flowable, Paragraph):\\n style = flowable.style.name\\n txt = flowable.getPlainText()\\n\\n if style == 'Title':\\n self.title = txt\\n elif style == 'Heading1':\\n self.chapter = txt \\n key = 'ch%s' % self.seq.nextf('chapter')\\n self.canv.bookmarkPage(key)\\n self.canv.addOutlineEntry(txt, key, 0, 0)\\n self.seq.reset(\\\"section\\\")\\n self.notify('TOCEntry', (0, txt, self.page, key))\\n elif style == 'Heading2':\\n self.section = flowable.text\\n key = 'ch%ss%s' % (self.seq.thisf(\\\"chapter\\\"), self.seq.nextf(\\\"section\\\"))\\n self.canv.bookmarkPage(key)\\n self.canv.addOutlineEntry(txt, key, 1, 0)\\n self.notify('TOCEntry', (1, txt, self.page, key))\",\n \"def generate_paragraphs(self):\\n def dig(hr_tag, end_index):\\n paragraphs = []\\n for tag in hr_tag.children:\\n if tag.name == 'hr':\\n return paragraphs + dig(tag, end_index)\\n text = (str(tag)\\n if isinstance(tag, NavigableString)\\n else tag.get_text())\\n if '$' in text and not tag.find('table'):\\n start_index = document_txt.index(text[:search_chars])\\n end_index = start_index + len(text)\\n paragraphs.append({\\n 'text': text,\\n 'start': start_index,\\n 'end': end_index\\n })\\n return paragraphs\\n\\n with open('document.txt', 'rb') as f1:\\n document_txt = f1.read().decode()\\n search_chars = 20\\n paragraphs = dig(self.soup.find('body'), 0)\\n paragraphs = sorted(paragraphs, key=lambda x: x['start'])\\n with open('paragraphs.txt', 'wb') as f2:\\n f2.write(json.dumps(paragraphs, indent=2, sort_keys=True).encode())\",\n \"def onMainToMnemo(self):\\n self.second_mnemo_text.SetFocus()\",\n \"def check_paragraph(self, para, links_para):\\n #Return False if no paragraphs found\\n if para is None:\\n return False\\n\\n links = para.find_all('a')\\n #Return False if no links found\\n if links is None:\\n return False\\n\\n #Return True if one link is valid in the paragraph\\n for link in links:\\n if self.check_link(link, links_para):\\n return True\\n return False\",\n \"def process(self, doc):\\n # don't try to process null notes\\n if not doc[1]:\\n if self.verbose:\\n print(\\\"Error segmenting doc\\\",doc[0])\\n return []\\n # odd notes may throw an error. Just continue rather than stopping the entire process\\n try:\\n sentences = self.sentence_tokenizer.segToSentenceSpans(doc[1])\\n except KeyError:\\n if self.verbose:\\n print(\\\"Error segmenting doc\\\",doc[0])\\n return []\\n\\n #context_doc = pyConTextGraph.ConTextDocument() # ConTextDoc not needed for simple usage\\n\\n doc_annots = list()\\n\\n for sentence in sentences:\\n # run sentence tokenizer on input text, return the spans\\n sentence_text = doc[1][sentence.begin:sentence.end]\\n # process every sentence by adding markup\\n markup = pyConTextGraph.ConTextMarkup()\\n markup.setRawText(sentence_text)\\n markup.cleanText()\\n # apply targets and modifiers\\n markup.markItems(self.targets, mode=\\\"target\\\")\\n markup.markItems(self.modifiers, mode=\\\"modifier\\\")\\n # address scope of modifiers to targets, remove inactive modifiers and self-modifying relationships\\n markup.pruneMarks()\\n markup.applyModifiers()\\n markup.pruneSelfModifyingRelationships()\\n markup.dropInactiveModifiers()\\n\\n marked_targets = markup.getMarkedTargets()\\n for marked_target in marked_targets:\\n modifiers = markup.getModifiers(marked_target)\\n if not modifiers:\\n span = (sentence.begin+marked_target.getSpan()[0],sentence.begin+marked_target.getSpan()[1])\\n if self.mode == 'combined':\\n annot = (doc[0], marked_target.getPhrase(), span[0], span[1], marked_target.getCategory()[0]+'_unspecified', marked_target.getCode())\\n elif self.mode == 'separate':\\n annot = (doc[0], marked_target.getPhrase(), span[0], span[1], marked_target.getCategory()[0], 'unspecified', marked_target.getCode())\\n if annot not in doc_annots:\\n doc_annots.append(annot)\\n else:\\n for modifier in modifiers:\\n if marked_target.getSpan()[0] < modifier.getSpan()[0]:\\n span = (sentence.begin+marked_target.getSpan()[0],sentence.begin+modifier.getSpan()[1])\\n else:\\n span = (sentence.begin+modifier.getSpan()[0],sentence.begin+marked_target.getSpan()[1])\\n if self.mode == 'combined':\\n annot = (doc[0], doc[1][span[0]:span[1]], span[0], span[1], marked_target.getCategory()[0]+'_'+modifier.getCategory()[0], marked_target.getCode())\\n elif self.mode == 'separate':\\n annot = (doc[0], doc[1][span[0]:span[1]], span[0], span[1], marked_target.getCategory()[0], modifier.getCategory()[0], marked_target.getCode())\\n if annot not in doc_annots:\\n doc_annots.append(annot)\\n\\n #context_doc.addMarkup(markup)\\n\\n return doc_annots\",\n \"def test_reformat_paragraph_new_code_8_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 41.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 41.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"1.0\\\"),\\n after_sel=(\\\"3.0\\\", \\\"3.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def text_by_paragraph(self,\\r\\n filename,\\r\\n splitchar=EOL,\\r\\n keys=True,\\r\\n key_definitions=False,\\r\\n query=True):\\r\\n\\r\\n\\r\\n analysetext = file_access.get_text_file(filename)\\r\\n #load the text to be analysed\\r\\n\\r\\n if keys:\\r\\n\\r\\n possible_keys = set()\\r\\n if len(self.keys())>50:\\r\\n nprint (\\\"TOO MANY KEYS\\\")\\r\\n for key in self.keys():\\r\\n #grab all keys, removing tags.\\r\\n #DESIDERATUM: Make it possible to\\r\\n #restrict the range of notes\\r\\n #from which the keys are grabbed\\r\\n\\r\\n if SLASH in key:\\r\\n if key.split(SLASH)[0] != EMPTYCHAR:\\r\\n possible_keys.add(key.split(SLASH)[0].lower())\\r\\n else:\\r\\n possible_keys.add(key.split(SLASH)[0].lower())\\r\\n\\r\\n\\r\\n possible_keys = list(possible_keys)\\r\\n\\r\\n possible_keys = show_list(possible_keys,\\r\\n from_here=0,\\r\\n to_here=len(possible_keys),\\r\\n label='KEYS',\\r\\n select=True,\\r\\n display=display)\\r\\n # show the keys through display\\r\\n #object and select which are to be kept\\r\\n possible_keys += input(queries.ADDITIONAL_KEYS).split(COMMA)\\r\\n display.noteprint((labels.KEYS,\\r\\n formkeys(possible_keys)))\\r\\n\\r\\n\\r\\n for paragraph in analysetext.split(splitchar):\\r\\n # iterate over segments of the text to be analysed\\r\\n found_words = set()\\r\\n keyset = set()\\r\\n\\r\\n if keys:\\r\\n found_words.update({a_temp for a_temp in get_words(paragraph)\\r\\n if len(a_temp) > 3}.intersection(set(possible_keys)))\\r\\n # make a set of all the words that have been found\\r\\n keyset = found_words\\r\\n if key_definitions:\\r\\n found_words.update(self.default_dict['definitions']\\r\\n .return_keys(get_words(paragraph)))\\r\\n keyset = found_words\\r\\n\\r\\n display.noteprint((formkeys(keyset),\\r\\n nformat.encase(paragraph,\\r\\n found_words,\\r\\n surround=False)))\\r\\n # display the segment as a note\\r\\n #with found words encased\\r\\n #in arrow brackets\\r\\n\\r\\n if not query:\\r\\n if keyset == set():\\r\\n keyset = {VOIDTERM}\\r\\n if paragraph.strip() != EMPTYCHAR:\\r\\n self.enter(ek=keyset,\\r\\n et=paragraph)\\r\\n\\r\\n else:\\r\\n\\r\\n if input(queries.INCLUDE) in YESTERMS+[EMPTYCHAR]:\\r\\n # ask if the found words\\r\\n #should be included as keys\\r\\n\\r\\n newkeys = set(input(formkeys(keyset)\\r\\n +queries.KEYWORDS_TO_ADD).split(COMMA)).union(keyset)\\r\\n if paragraph.strip() != EMPTYCHAR:\\r\\n self.enter(ek=newkeys, et=paragraph)\\r\\n if input(queries.CONTINUE + BLANK) not in YESTERMS+[EMPTYCHAR]:\\r\\n break\",\n \"def processJumpTable(jt_ea):\",\n \"def match_first_paragraph():\\n html = \\\"<p>pybites != greedy</p>\\\" \\\"<p>not the same can be said REgarding ...</p>\\\"\\n\\n pattern = \\\"<p>(.+?)</p>\\\"\\n text = html\\n\\n match = re.findall(pattern, text)\\n return match[0]\",\n \"def _add_article(self, link, index=None):\\n if self.verbose:\\n sys.stdout.write(\\\".\\\")\\n sys.stdout.flush()\\n\\n link_url = self.base_url + link\\n pdf_filepath = (\\n self.output_raw_dir\\n + \\\"/FOMC_PresConfScript_\\\"\\n + self._date_from_link(link)\\n + \\\".pdf\\\"\\n )\\n\\n if not os.path.exists(pdf_filepath) or self.force_download:\\n # Scripts are provided only in pdf. Save the pdf and pass the content\\n res = requests.get(link_url)\\n\\n with open(pdf_filepath, \\\"wb\\\") as f:\\n f.write(res.content)\\n else:\\n if self.verbose:\\n print(\\\"File already exists: \\\", pdf_filepath)\\n\\n # Extract text from the pdf\\n pdf_file_parsed = \\\"\\\" # new line\\n with pdfplumber.open(pdf_filepath) as pdf:\\n for page in pdf.pages:\\n pg_width = page.width\\n pg_height = page.height\\n pg_bbox = (\\n self.crop_coords[0] * float(pg_width),\\n self.crop_coords[1] * float(pg_height),\\n self.crop_coords[2] * float(pg_width),\\n self.crop_coords[3] * float(pg_height),\\n )\\n page_crop = page.crop(bbox=pg_bbox)\\n text = page_crop.extract_text()\\n pdf_file_parsed = pdf_file_parsed + \\\"\\\\n\\\" + text\\n paragraphs = re.sub(\\\"(\\\\n)(\\\\n)+\\\", \\\"\\\\n\\\", pdf_file_parsed.strip())\\n paragraphs = paragraphs.split(\\\"\\\\n\\\")\\n\\n section = -1\\n paragraph_sections = []\\n for paragraph in paragraphs:\\n if not re.search(\\n \\\"^(page|january|february|march|april|may|june|july|august|september|october|november|december|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\\",\\n paragraph.lower(),\\n ):\\n if len(re.findall(r\\\"[A-Z]\\\", paragraph[:10])) > 5 and not re.search(\\n \\\"(present|frb/us|abs cdo|libor|rp–ioer|lsaps|cusip|nairu|s cpi|clos, r)\\\",\\n paragraph[:10].lower(),\\n ):\\n section += 1\\n paragraph_sections.append(\\\"\\\")\\n if section >= 0:\\n paragraph_sections[section] += paragraph\\n self.articles[index] = self.segment_separator.join(\\n [paragraph for paragraph in paragraph_sections]\\n )\",\n \"def footnoteRef(self, text):\\n return re.compile(r'(?<=\\\\S)\\\\[(\\\\d+)(!?)\\\\](\\\\s)?', re.U).sub(\\n self.footnoteID, text\\n )\",\n \"def _paragraphs_raw(self):\\n for par in self.parsed.find_all(\\\"p\\\")[self.PAR_START:]:\\n yield par\",\n \"def test_reformat_paragraph_list_4_of_5(self):\\n before_b = \\\"\\\"\\\"\\\\\\n This paragraph leads of this test. It is\\n the \\\"lead\\\" paragraph.\\n\\n 1. This is item number 1. It is the\\n first item in the list.\\n\\n 2. This is item number 2. It is the\\n second item in the list.\\n\\n 3. This is item \\n number 3. It is the third item in the list.\\n\\n This paragraph ends the test. It is the \\\"final\\\"\\n paragraph.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n This paragraph leads of this test. It is\\n the \\\"lead\\\" paragraph.\\n\\n 1. This is item number 1. It is the\\n first item in the list.\\n\\n 2. This is item number 2. It is the\\n second item in the list.\\n\\n 3. This is item number 3. It is the\\n third item in the list.\\n\\n This paragraph ends the test. It is the \\\"final\\\"\\n paragraph.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"10.0\\\", \\\"10.0\\\"),\\n after_sel=(\\\"13.0\\\", \\\"13.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def get_chapter_text(location):\\n chapter_output_dictionary = {}\\n chapter_contents_list = []\\n\\n soup = Ripper(location, parser=\\\"html5lib\\\", save_path=save_path).soup\\n text = soup.find(\\\"table\\\", class_=\\\"texttable\\\")\\n\\n for each in text.find_all(\\\"p\\\"):\\n attributes = each.attrs\\n if attributes:\\n if \\\"desc\\\" in attributes[\\\"class\\\"]:\\n pass\\n elif \\\"note\\\" in attributes[\\\"class\\\"]:\\n pass\\n else:\\n new_cont = each.contents\\n chapter_contents_list.extend(new_cont)\\n return join_chapter_text(chapter_contents_list)\",\n \"def parse(text):\\n md = markdown.Markdown(['codehilite', 'tables', ])\\n\\n for iref in re.findall(img_ref_re, text):\\n img_id = iref[7]\\n try:\\n image = FlatPageImage.objects.get(pk=int(img_id))\\n md.references[img_id] = (image.image_path.url, '')\\n except ObjectDoesNotExist:\\n pass\\n\\n for lref in re.findall(reference_re, text):\\n doc_name = lref[7]\\n try:\\n doc = File.objects.get(name=doc_name)\\n md.references[doc_name]= (doc.url, doc.name)\\n except ObjectDoesNotExist:\\n pass\\n\\n return md.convert(text)\",\n \"def getDataParagraph(startpattern,stoppattern,datararray):\\n output = []\\n inparagraph = 'FALSE'\\n lines=datararray\\n for i in range(len(lines)):\\n search_start=re.search(r'{0}'.format(startpattern),lines[i])\\n if search_start is not None or inparagraph == 'TRUE':\\n inparagraph = 'TRUE'\\n lines[i] = lines[i].split('\\\\n')[0]\\n if lines[i].startswith('*'):\\n pass\\n else:\\n output.append(lines[i])\\n search_stop=re.search(r'{0}'.format(stoppattern),lines[i])\\n if search_stop is not None:\\n return output\\n pass\",\n \"def footnote_item(self, key, text):\\n back = (\\n '<a href=\\\"#fnref-%s\\\" class=\\\"footnote\\\">↩</a>'\\n ) % escape(key)\\n text = text.rstrip()\\n if text.endswith('</p>'):\\n text = re.sub(r'<\\\\/p>$', r'%s</p>' % back, text)\\n else:\\n text = '%s<p>%s</p>' % (text, back)\\n html = '<li id=\\\"fn-%s\\\">%s</li>\\\\n' % (escape(key), text)\\n return html\",\n \"def find_text_in_p(self, el):\\n\\n all = []\\n for el in el.findall(\\\".//p\\\"):\\n t = el.text_content().strip()\\n if len(t)<40:\\n continue\\n all.append(t)\\n\\n return \\\" \\\".join(all)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5886465","0.58725065","0.58705807","0.57472676","0.56360775","0.55975014","0.5573705","0.5540514","0.54371405","0.54029816","0.53338504","0.53178537","0.5315798","0.5282773","0.52491987","0.52362645","0.5195637","0.5168886","0.513893","0.51377296","0.5118753","0.5088631","0.5075016","0.5071764","0.5047268","0.5017047","0.5005871","0.49910498","0.49874976","0.4936778","0.4926041","0.4919049","0.4877412","0.48595953","0.48499316","0.48443785","0.47922003","0.47802982","0.47675872","0.47646645","0.47511595","0.47256246","0.47139958","0.47078016","0.47020352","0.4697681","0.46869442","0.4673873","0.46729764","0.46578866","0.46558815","0.4647966","0.46325785","0.46244353","0.46235827","0.46217126","0.46063894","0.46021205","0.46020183","0.4584548","0.45799038","0.4567086","0.45667344","0.4557137","0.45494983","0.45479178","0.453415","0.45320606","0.45314157","0.45312214","0.45263898","0.4525976","0.45239428","0.45231903","0.4522102","0.45092356","0.45060197","0.4505863","0.45053294","0.4504869","0.45047733","0.45047733","0.450352","0.4501385","0.4496951","0.44891357","0.44842756","0.4479969","0.4478814","0.44782898","0.4460351","0.44595334","0.44510978","0.44501644","0.4449899","0.444508","0.4444739","0.44423863","0.4441433","0.4428486"],"string":"[\n \"0.5886465\",\n \"0.58725065\",\n \"0.58705807\",\n \"0.57472676\",\n \"0.56360775\",\n \"0.55975014\",\n \"0.5573705\",\n \"0.5540514\",\n \"0.54371405\",\n \"0.54029816\",\n \"0.53338504\",\n \"0.53178537\",\n \"0.5315798\",\n \"0.5282773\",\n \"0.52491987\",\n \"0.52362645\",\n \"0.5195637\",\n \"0.5168886\",\n \"0.513893\",\n \"0.51377296\",\n \"0.5118753\",\n \"0.5088631\",\n \"0.5075016\",\n \"0.5071764\",\n \"0.5047268\",\n \"0.5017047\",\n \"0.5005871\",\n \"0.49910498\",\n \"0.49874976\",\n \"0.4936778\",\n \"0.4926041\",\n \"0.4919049\",\n \"0.4877412\",\n \"0.48595953\",\n \"0.48499316\",\n \"0.48443785\",\n \"0.47922003\",\n \"0.47802982\",\n \"0.47675872\",\n \"0.47646645\",\n \"0.47511595\",\n \"0.47256246\",\n \"0.47139958\",\n \"0.47078016\",\n \"0.47020352\",\n \"0.4697681\",\n \"0.46869442\",\n \"0.4673873\",\n \"0.46729764\",\n \"0.46578866\",\n \"0.46558815\",\n \"0.4647966\",\n \"0.46325785\",\n \"0.46244353\",\n \"0.46235827\",\n \"0.46217126\",\n \"0.46063894\",\n \"0.46021205\",\n \"0.46020183\",\n \"0.4584548\",\n \"0.45799038\",\n \"0.4567086\",\n \"0.45667344\",\n \"0.4557137\",\n \"0.45494983\",\n \"0.45479178\",\n \"0.453415\",\n \"0.45320606\",\n \"0.45314157\",\n \"0.45312214\",\n \"0.45263898\",\n \"0.4525976\",\n \"0.45239428\",\n \"0.45231903\",\n \"0.4522102\",\n \"0.45092356\",\n \"0.45060197\",\n \"0.4505863\",\n \"0.45053294\",\n \"0.4504869\",\n \"0.45047733\",\n \"0.45047733\",\n \"0.450352\",\n \"0.4501385\",\n \"0.4496951\",\n \"0.44891357\",\n \"0.44842756\",\n \"0.4479969\",\n \"0.4478814\",\n \"0.44782898\",\n \"0.4460351\",\n \"0.44595334\",\n \"0.44510978\",\n \"0.44501644\",\n \"0.4449899\",\n \"0.444508\",\n \"0.4444739\",\n \"0.44423863\",\n \"0.4441433\",\n \"0.4428486\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6464983"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3182,"cells":{"query":{"kind":"string","value":"Tokenize on linebyline basis."},"document":{"kind":"string","value":"def tokenize_generic(self, tokenizer, N=None, drop_punctuation=True):\n ct, done = 0, False\n with open(self.textfile) as f:\n for ln in f.readlines():\n if done:\n break\n ln = ln.replace(\"(return)\", \"\")\n for token in tokenizer(ln.strip()):\n if not done:\n if (not drop_punctuation) or (token not in self.punctuation):\n yield token\n ct += 1\n if (N is not None ) and ct == N:\n done = True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def tokenize_words(line):\n return","def tokenize(\n self, text_row: Optional[List[str]], token_row: Optional[List[List[str]]]\n ):\n raise NotImplementedError","def tokenize_line(line, max_line_length=None, number_token=None, name_token=None, gpe_token=None):\n new_line = word_tokenize(line,\n number_token=number_token,\n name_token=name_token,\n gpe_token=gpe_token)\n if max_line_length:\n new_line = new_line[:max_line_length]\n new_line = vector_to_string(new_line)\n return new_line","def tokenize(src):\n\n pass","def tokenize(self, lines):\n tokens = []\n\n for line_number, line in enumerate(lines):\n self._line_number = line_number + 1\n self._line = line.rstrip('\\r\\n')\n\n last_end = 0\n for token in _TOKEN_RE.finditer(self._line):\n if token.start() != last_end:\n self.error(\n 'invalid token',\n token=Token('INVALID',\n self._line[last_end:token.start()],\n self.filename, self._line,\n self._line_number, last_end))\n last_end = token.end()\n\n # Omit whitespace and comments now to avoid sprinkling this logic\n # elsewhere.\n if token.lastgroup in ('WHITESPACE', 'COMMENT',\n 'CONTINUATION'):\n continue\n tokens.append(\n Token(token.lastgroup, token.group(), self.filename,\n self._line, self._line_number, token.start()))\n if last_end != len(self._line):\n self.error(\n 'invalid token',\n token=Token('INVALID', self._line[last_end:],\n self.filename, self._line, self._line_number,\n last_end))\n\n if self._line.endswith('\\\\'):\n # This line is not finished yet.\n continue\n\n if tokens:\n # Return a copy of the token list so that the caller can be free\n # to modify it.\n yield tokens[::]\n tokens.clear()","def tokenize(lines, token='word'):\n if token == 'word':\n return [line.split() for line in lines]\n elif token == 'char':\n return [list(line) for line in lines]\n else:\n print('ERROR: unknown token type: ' + token)","def _tokenize_line(self, line: str, pattern='\\W'):\n # TODO check nltk tokenize\n # TODO check string not to lower\n line = re.sub(\"[.,;:]\", \" \", line)\n return re.split(pattern, line.lower())","def _tokenize(source):\n lines = source.split(\"\\n\")\n print(\n \"{type:<10}{string:<25} {start:^12} {end:^12}\".format(\n type=\"Type\", string=\"String\", start=\"Start\", end=\"End\"\n )\n )\n print(\"-\" * 60)\n for line in lines:\n tokens = collect_tokens(line)\n for token in tokens:\n print(token)","def tokenize(self, input): # pylint: disable=redefined-builtin\n (tokens, _, _) = self.tokenize_with_offsets(input)\n return tokens","def tokenise(sample):\n\n processed = sample.split()\n return processed","def tokenize(fp):\n for line in fp:\n line = line.strip()\n if line[0] == '#':\n continue\n for tok in line.split():\n yield tok","def _batch_tokenize(self, text: List[str]) -> List[List[str]]:\n return self.bert_model.batch_tokenize([t.strip() for t in text])","def tokenize(line):\n tokens = [x for x in re.split(\"[ \\f\\n\\r\\t\\v,()]+\", line) if x]\n return tokens[0], tokens[1:]","def tokenize(self, raw_text):\n # TODO implement\n raw_tokens = word_tokenize(raw_text.decode('utf8'))\n return self.filter_tokens(raw_tokens)\n # return self.split_by(raw_tokens, '-')","def collect_tokens(line):\n tokens = []\n try:\n for tok in tokenize.generate_tokens(StringIO(line).readline):\n token = Token(tok)\n if not token.string.strip(): # ignore spaces\n continue\n if token.type == tokenize.COMMENT:\n break\n tokens.append(token)\n except tokenize.TokenError:\n return []\n except Exception as e:\n print(\"%s raised in utils.collect_tokens\" % repr(e))\n\n return tokens","def tokenize(self, text):\n text = convert_to_unicode(text)\n text = self._clean_text(text)\n\n # This was added on November 1st, 2018 for the multilingual and Chinese\n # models. This is also applied to the English models now, but it doesn't\n # matter since the English models were not trained on any Chinese data\n # and generally don't have any Chinese data in them (there are Chinese\n # characters in the vocabulary because Wikipedia does have some Chinese\n # words in the English Wikipedia.).\n text = self._tokenize_chinese_chars(text)\n\n orig_tokens = whitespace_tokenize(text)\n split_tokens = []\n for token in orig_tokens:\n if self.do_lower_case:\n token = token.lower()\n token = self._run_strip_accents(token)\n if self.split_on_punc:\n split_tokens.extend(self._run_split_on_punc(token))\n else:\n split_tokens.append(token) # pragma: no cover\n\n output_tokens = whitespace_tokenize(\" \".join(split_tokens))\n return output_tokens","def tokenize(line):\n line = line.strip()\n tokens = deque()\n permanent = line.startswith('@')\n if permanent:\n line = line[1:]\n while line:\n token, line, comment = OrdersParser._get_token(line)\n if comment:\n return (tokens, permanent, token)\n else:\n tokens.append(token)\n \n return (tokens, permanent, None)","def tokenize(raw_text):\n def _xop(tokens):\n def _(x):\n return xop(x, \"op\", tokens)\n return _\n \n raw_tokens=xversa_split(raw_text, tokens=Op_Tokens+Group_Tokens)\n tokens=map(xtotype, raw_tokens) \n tokens=map(_xop(Op_Tokens+Group_Tokens), tokens)\n return tokens","def tokenize_wrapper(input):\n skip = {token.NEWLINE, token.INDENT, token.DEDENT}\n tokens = tokenize.generate_tokens(io.StringIO(input).readline)\n for quintuple in tokens:\n type, value, start, end, line_text = quintuple\n if type not in skip:\n yield quintuple","def _tokenize(self, text):\n split_tokens = []\n for token in self.basic_tokenizer.tokenize(text):\n for sub_token in self.wordpiece_tokenizer.tokenize(token):\n split_tokens.append(sub_token)\n return split_tokens","def tokenize(self, text):\n text = utils.convert_to_unicode(text)\n text = self._clean_text(text)\n\n # This was added on November 1st, 2018 for the multilingual and Chinese\n # models. This is also applied to the English models now, but it doesn't\n # matter since the English models were not trained on any Chinese data\n # and generally don't have any Chinese data in them (there are Chinese\n # characters in the vocabulary because Wikipedia does have some Chinese\n # words in the English Wikipedia.).\n text = self._tokenize_chinese_chars(text)\n\n orig_tokens = whitespace_tokenize(text)\n split_tokens = []\n for token in orig_tokens:\n if self.do_lower_case:\n token = token.lower()\n token = self._run_strip_accents(token)\n split_tokens.extend(self._run_split_on_punc(token))\n\n output_tokens = whitespace_tokenize(\" \".join(split_tokens))\n return output_tokens","def _split_to_tokens(self, file_content: str):\n cur_token = ''\n string_started = False\n for line in file_content.split('\\n'):\n cur_token = ''\n line = line.strip()\n if line.startswith('#'): # skip comments\n continue\n for char in line:\n if string_started:\n if char == '\"': # string ended\n self._add_non_empty_token(cur_token)\n cur_token = '' # start of a new string\n string_started = False\n else:\n cur_token += char\n elif char == '\"':\n self._add_non_empty_token(cur_token)\n cur_token = '' # start of a new string\n string_started = True\n elif (char == \" \" and not string_started) or char == '\\n':\n self._add_non_empty_token(cur_token)\n cur_token = ''\n elif char in [':', '{', '}', '[', ']', ',']:\n self._add_non_empty_token(cur_token)\n self._tokens.append(char)\n cur_token = ''\n else:\n cur_token += char\n self._add_non_empty_token(cur_token)\n self._add_non_empty_token(cur_token)","def tokenize_line(line, row, col):\n if len(line) == 0:\n return []\n\n # skip spaces\n if line[0].isspace():\n return tokenize_line(line[1:], row, col + 1)\n\n # check for comments\n if line[0] == '#':\n return []\n\n first_token = None\n\n # check for the first token\n for token_type, token_regex, value_func in token_lex_info_list:\n match = re.match(token_regex, line)\n if match is not None:\n uncooked = match.group(0)\n if first_token is None or\\\n len(first_token.uncooked) < len(uncooked):\n first_token = Token(type = token_type,\n value = value_func(uncooked),\n uncooked = uncooked,\n location = (row, col))\n\n if first_token is None:\n raise LexerException(\"Invalid token\", (row, col))\n else:\n token_len = len(first_token.uncooked)\n line_tail = line[token_len:]\n return [first_token] + tokenize_line(line_tail, row, col + token_len)","def basic_tokenizer(line, normalize_digits=True):\n #returns words: array of tokens\n #removes <u>, </u>, [, ] from given line\n line = re.sub('<u>', '', line) #re.sub is regex\n line = re.sub('</u>', '', line)\n line = re.sub('\\[', '', line)\n line = re.sub('\\]', '', line)\n words = []\n #re.compiles a regex into a regex object so match or search can be used\n #python 3: b\"\" turns string into \"bytes literal\" which turns string into byte. Ignored in Python 2\n #r string prefix is raw string: '\\n' is \\,n instead of newline\n _WORD_SPLIT = re.compile(b\"([.,!?\\\"'-<>:;)(])\") #includes () for re.split below\n _DIGIT_RE = re.compile(r\"\\d\")\n #strip removes whitespace at beginning and end\n #lowercase string\n for fragment in line.strip().lower().split(): #each of these is a fragment ['you,', 'are', 'here!']\n for token in re.split(_WORD_SPLIT, fragment): #each token splits each fragment i.e. each token in ['here', '!']\n if not token: #if empty array\n continue\n if normalize_digits: #substitutes digits with #\n token = re.sub(_DIGIT_RE, b'#', token)\n words.append(token)\n return words","def tokeneater(self, toktype, toktext, (srow,scol), (erow,ecol), line):\n # If we encounter any errors, then just give up.\n if toktype == token.ERRORTOKEN:\n raise tokenize.TokenError, toktype\n\n # Did we skip anything whitespace? If so, add a pseudotoken\n # for it, with toktype=None. (Note -- this skipped string\n # might also contain continuation slashes; but I won't bother\n # to colorize them.)\n startpos = self.line_offsets[srow] + scol\n if startpos > self.pos:\n skipped = self.text[self.pos:startpos]\n self.cur_line.append( (None, skipped) )\n\n # Update our position.\n self.pos = startpos + len(toktext)\n\n # Update our current line.\n self.cur_line.append( (toktype, toktext) )\n\n # When we reach the end of a line, process it.\n if toktype == token.NEWLINE or toktype == token.ENDMARKER:\n self.handle_line(self.cur_line)\n self.cur_line = []","def tokenize(self, text):\n text = convert_to_unicode(text)\n text = self.clean_text(text)\n\n # This was added on November 1st, 2018 for the multilingual and Chinese\n # models. This is also applied to the English models now, but it doesn't\n # matter since the English models were not trained on any Chinese data\n # and generally don't have any Chinese data in them (there are Chinese\n # characters in the vocabulary because Wikipedia does have some Chinese\n # words in the English Wikipedia.).\n text = self._add_space_around_cjk_chars(text)\n\n orig_tokens = split_by_whitespace(text)\n split_tokens = []\n for token in orig_tokens:\n if self.do_lower_case:\n token = token.lower()\n token = remove_accents(token)\n split_tokens.extend(split_by_punctuation(token))\n\n output_tokens = split_by_whitespace(\" \".join(split_tokens))\n return output_tokens","def tokenize(text):\n sentence = Sentence(text)\n return sentence.tokens()","def tokenize(text, token):\n text = [token(x) for x in text]\n return text","def line2Token(linein):\n#\t\"\"\" input=readlines() output=token\"\"\n\tlistout = []\n\tfor s in linein:\n\t\tif s==\"\":\n\t\t\tcontinue\n\t\ts = string.replace(s,'\\n','')\n\t\ts = string.replace(s,',',' ')\n s = string.replace(s,'=',\"= \")\n\t\ts = string.replace(s,':',\": \")\n\n\t\tlista=string.split(s)\n\t\tfor x in lista:\n\t\t\tif x<>\"\":\n\t\t\t\tlistout.append(x)\n\n\treturn listout","def tokenize(\n tokenizer: Tokenizer,\n lines: typing.Iterable[str],\n language: typing.Optional[str] = None,\n is_csv: bool = False,\n csv_delimiter: str = \"|\",\n split_sentences: bool = False,\n inline_pronunciations: bool = False,\n) -> typing.Iterable[typing.Dict[str, typing.Any]]:\n # String used to join tokens.\n # See RegexTokenizer\n join_str: str = getattr(tokenizer, \"join_str\", \" \")\n\n if inline_pronunciations:\n assert language is not None\n lang_phonemes = gruut_ipa.Phonemes.from_language(language)\n assert lang_phonemes is not None, f\"Unsupported language {language}\"\n\n def process_lines(lines):\n for line in lines:\n yield encode_inline_pronunciations(line, lang_phonemes)\n\n lines = process_lines(lines)\n\n for line in lines:\n line = line.strip()\n if not line:\n continue\n\n utt_id = \"\"\n\n if is_csv:\n # Input format is id|text\n utt_id, line = line.split(csv_delimiter, maxsplit=1)\n\n sentences = list(tokenizer.tokenize(line))\n\n if split_sentences:\n # One output line per sentence\n for sentence_idx, sentence in enumerate(sentences):\n sentence_id = str(sentence_idx)\n if utt_id:\n sentence_id = f\"{utt_id}_{sentence_id}\"\n\n yield {\n \"id\": sentence_id,\n \"raw_text\": sentence.raw_text,\n \"raw_words\": sentence.raw_words,\n \"clean_words\": sentence.clean_words,\n \"tokens\": [dataclasses.asdict(t) for t in sentence.tokens],\n \"clean_text\": sentence.clean_text,\n \"sentences\": [],\n }\n else:\n # One output line per input line\n raw_words: typing.List[str] = []\n clean_words: typing.List[str] = []\n tokens: typing.List[Token] = []\n\n for sentence in sentences:\n raw_words.extend(sentence.raw_words)\n clean_words.extend(sentence.clean_words)\n tokens.extend(sentence.tokens)\n\n yield {\n \"id\": utt_id,\n \"raw_text\": line,\n \"raw_words\": raw_words,\n \"clean_words\": clean_words,\n \"tokens\": [dataclasses.asdict(t) for t in tokens],\n \"clean_text\": join_str.join(clean_words),\n \"sentences\": [dataclasses.asdict(s) for s in sentences],\n }","def tokenize(self, rawt):\n def createtokens(rawt):\n for oper in self.control.sortedopers:\n if oper in rawt:\n par = rawt.partition(oper)\n return createtokens(par[0]) + [par[1]] + createtokens(par[2])\n for punc in self.control.punctuation:\n if punc in rawt:\n par = rawt.partition(punc)\n return createtokens(par[0]) + [par[1]] + createtokens(par[2])\n return [rawt]\n tokens = [token for token in createtokens(rawt) if token]\n ret = []\n currentquote = None\n for token in tokens:\n if token in self.control.allquotes and token:\n if currentquote == None:\n ret.append(token)\n currentquote = token\n else:\n if token == currentquote:\n currentquote = None\n ret[-1] += token\n elif currentquote:\n ret[-1] += token\n else:\n ret.append(token)\n #@define stuff\n linep = 0\n while linep < len(ret): \n if ret[linep] and ret[linep] in self.control.datadef:\n self.control.applyrules(ret.args.pop(0))\n linep+=1\n ret2 = []\n for token in ret:\n if token:\n if token[0] not in self.control.allquotes:\n if token.strip(self.control.nbwhitespace):\n if __debug__:\n assert token[-1] not in self.control.allquotes, token\n ret2.append(token.strip(self.control.nbwhitespace))\n else:\n ret2.append(token)\n\n ret = []\n for e in (e.strip(self.control.nbwhitespace) for e in ret2):\n if not ret or not e or e not in self.control.delims['endline']\\\n or str(ret[-1].data) not in self.control.delims['endline']:\n ret.append(group(e, control = self.control))\n # quit(list(str(x) for x in ret))\n return ret\n # return [group(e, control = self.control) for e in (e.strip(self.control.nbwhitespace) for e in ret2) if e]","def tokenize(text):\n return text.split(' ')","def basic_tokenizer(line, normalize_digits=True):\n line = re.sub(b'<u>', b'', line)\n line = re.sub(b'</u>', b'', line)\n line = re.sub(br'\\[', b'', line)\n line = re.sub(br'\\]', b'', line)\n words = []\n _WORD_SPLIT = re.compile(b\"([.,!?\\\"'-<>:;)(])\")\n _DIGIT_RE = re.compile(br\"\\d\")\n for fragment in line.strip().lower().split():\n for token in re.split(_WORD_SPLIT, fragment):\n if not token:\n continue\n if normalize_digits:\n token = re.sub(_DIGIT_RE, b'#', token)\n words.append(token)\n return words","def tokenize(self, text):\n text = self._clean_text(text)\n text = self._tokenize_chinese_chars(text)\n orig_tokens = whitespace_tokenize(text)\n split_tokens = []\n for token in orig_tokens:\n if self.do_lower_case and token not in self.never_split:\n token = token.lower()\n token = self._run_strip_accents(token)\n split_tokens.extend(self._run_split_on_punc(token))\n output_tokens = whitespace_tokenize(' '.join(split_tokens))\n return output_tokens","def lex(lines):\n for line in lines:\n yield line.rstrip()","def _tokenize(self, text: str) -> List[str]:\n return self.bert_model.tokenize(text.strip())","def tokenize(fp):\n\n tokenizer = Tokenizer()\n\n for (lineno, line) in enumerate(fp):\n try:\n line = line.decode('utf8')\n except UnicodeDecodeError as detail:\n print >>sys.stderr, \"failed to decode line %i: %s\" % (lineno+1,\n detail)\n line = line.decode('utf8', 'replace')\n\n # This should use \"yield from ...\" (new in Python 3.3)\n for t in tokenizer.feed_data(line):\n yield t\n last = tokenizer.finalize()\n if last:\n yield last","def tokenize(self, text):\n # Ignore non-ASCII characters.\n text = remove_non_ascii(text)\n text = text.translate(Tokenizer.trans)\n tokens = [t for t in text.split() \n if len(t) >= self._config[u'min_len']\n and t not in self._config[u'stopwords']]\n self._counter.update(tokens)","def tokenize_with_offsets(self, input): # pylint: disable=redefined-builtin\n name = None\n with ops.name_scope(name, \"WhitespaceTokenize\", [input]):\n input_tensor = ragged_tensor.convert_to_tensor_or_ragged_tensor(input)\n if input_tensor.shape.ndims is None:\n raise ValueError(\"Rank of input_tensor must be statically known.\")\n if ragged_tensor.is_ragged(input_tensor):\n if input_tensor.flat_values.shape.ndims > 1:\n # If the flat_values of our ragged tensor is multi-dimensional, we can\n # process it separately and our output will have the same nested\n # splits as our input.\n (tokens, starts,\n ends) = self.tokenize_with_offsets(input_tensor.flat_values)\n return (input_tensor.with_flat_values(tokens),\n input_tensor.with_flat_values(starts),\n input_tensor.with_flat_values(ends))\n else:\n # Recursively process the values of the ragged tensor.\n (tokens, starts,\n ends) = self.tokenize_with_offsets(input_tensor.values)\n return (input_tensor.with_values(tokens),\n input_tensor.with_values(starts),\n input_tensor.with_values(ends))\n else:\n if input_tensor.shape.ndims > 1:\n # Convert the input tensor to ragged and process it.\n return self.tokenize_with_offsets(\n ragged_conversion_ops.from_tensor(input_tensor))\n elif input_tensor.shape.ndims == 0:\n (tokens, starts, ends) = self.tokenize_with_offsets(\n array_ops_stack.stack([input_tensor]))\n return tokens.values, starts.values, ends.values\n else:\n # Our rank 1 tensor is the correct shape, so we can process it as\n # normal.\n return self._whitespace_tokenize_with_offsets(input_tensor)","def tokenise(line):\n\n sline = str(line)\n tokens = []\n token = False\n quote = False\n tquote = \"\"\n start = 0\n for i in range(len(sline)):\n c = sline[i]\n if token and not quote:\n if c == \" \" or c == \"\\t\" or c == \"\\n\":\n # end of current token\n tokens.append(sline[start:i])\n token = False\n quote = False\n if token and (c == '\"' or c == \"'\"):\n # Detected a quote - flip the quote flag\n if quote:\n if c == tquote:\n quote = False\n else:\n quote = True\n tquote = c\n if not token:\n if c != \" \" and c != \"\\t\" and c != \"\\n\":\n # Start of a new token\n token = True\n start = i\n if c == '\"' or c == \"'\":\n # Also it's quoted\n quote = True\n tquote = c\n\n # End of the loop\n if token:\n # End of the last token\n tokens.append(sline[start : len(sline)])\n return tokens","def tokenize(self):\n\n self.feats = {\n 'features': [], # Lists of the `InputFeatures` objects.\n 'segments': [], # Segments of the phrase. 0: Promoun, 1: A-term, 2: B-term \n 'df_ids': [], # DataFrame index.\n 'target_token_ids': [] # Indexes of the target term in the tokens lists.\n }\n unique_id = 0 # Unique ID of the dataset.\n for _, row in tqdm(self.df.iterrows()):\n segment_tokens = self.tokenize_single_row(row)\n for j, segment in enumerate(segment_tokens):\n if segment['target_token_index'] > 0:\n features = self.tokens_to_features(unique_id, segment['tokens'])\n unique_id += 1\n self.feats['features'].append(features)\n self.feats['segments'].append(j)\n self.feats['target_token_ids'].append(segment['target_token_index'] )\n self.feats['df_ids'].append(row.ID)","def tokenize(tokenizer, max_length, stride, row):\r\n # The input data must be tokenized in the order dictated by the side the\r\n # selected checkpoint apply the padding\r\n pad_on_right = tokenizer.padding_side == \"right\"\r\n \r\n return tokenizer(\r\n row[\"question\" if pad_on_right else \"context\"],\r\n row[\"context\" if pad_on_right else \"question\"],\r\n max_length=max_length,\r\n truncation=\"only_second\" if pad_on_right else \"only_first\",\r\n return_overflowing_tokens=True,\r\n return_offsets_mapping=True,\r\n stride=stride,\r\n padding=\"max_length\",\r\n )","def preprocess_lines(movie_line):\n\ttokens = tokenizer.tokenize(movie_line)\n\twords = [word for word in tokens if word not in stopwords_set]\n\tstemmed_terms = [porter_stemmer.stem(word) for word in words]\n\tlemmatized_terms = [wordnet_lemmatizer.lemmatize(word) for word in stemmed_terms]\n\treturn lemmatized_terms","def identity_tokenizer(text):\n return text","def tokenize(self, path):\n assert os.path.exists(path)\n with open(path, 'r') as f:\n sentences = []\n for sentence in tqdm(f, desc='Processing file: {}'.format(path)):\n sentences.append(sentence.split())\n self.data = sentences","def process_line(line):\n [label, text] = line.split('\\t')\n return text.split()","def tokenize(text):\n source = list(text.rstrip().replace('\\n', ' '))\n return source","def tokenize(self, text):\n return self._tokenize(text)","def _tokenize(self, text: str) -> List[str]:\n text = text.lower().strip()\n return self.bpe.tokenize(text)","def get_tokens(line: str) -> Generator[str, None, None]:\n for token in line.rstrip().split():\n if len(token) > 0:\n yield token","def _tokenize(self, text: str) -> List[str]:\n return self.bpe.tokenize(text)","def tokenize(lines):\n\tfor line in lines:\n\t\tif line == '':\n\t\t\tcontinue\n\t\t\n\t\tif line.startswith('#'):\n\t\t\tcontinue\n\n\t\tif line.startswith('[') and line.endswith(']'):\n\t\t\tyield ('key', line[1:-1])\n\t\t\tcontinue\n\t\t\n\t\tvalues = tuple(map(float, line.split(' ')))\n\t\tyield ('values', values)\n\t\tcontinue","def tokenize(self, path, build_dict=False, thd=0):\n\n assert os.path.exists(path)\n\n if build_dict:\n # Add words to the dictionary\n with open(path, 'r') as f:\n for line in f:\n words = line.split()\n for word in words:\n self.dictionary.add_word(word)\n if thd > 1:\n self.dictionary.rebuild_by_freq(thd)\n\n # Tokenize file content\n ids_list = []\n with open(path, 'r') as f:\n for line in f:\n words = line.split()\n ids = []\n for word in words:\n ids.append(self.dictionary[word])\n ids_list.append(ids)\n\n return ids_list","def preprocess_file_to_tokens(self, dirPath, fnx):\n fnxPath = os.path.join(dirPath, fnx)\n with open(fnxPath) as f:\n fnx_data = f.read()\n fnx_data_nnl = re.sub(r'\\n', ' ', fnx_data)\n fnx_data_sb = re.sub(r\"( )+\", ' ', fnx_data_nnl)\n\n fnx_tokens = nltk.word_tokenize(fnx_data_sb)\n fnx_unk, fnx_tokens_prepped = self.infreq_to_UNK(fnx_tokens)\n \n return fnx_tokens_prepped","def tokenize(text):\n tokens=word_tokenize(text)\n lemmatizer=WordNetLemmatizer()\n \n clean_tokens=[]\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n return clean_tokens\n pass","def tokenize(self, line: str) -> List[str]:\n\n # expand shortcuts and aliases\n line = self._expand(line)\n\n # check if this line is a comment\n if line.lstrip().startswith(constants.COMMENT_CHAR):\n return []\n\n # split on whitespace\n try:\n tokens = shlex_split(line)\n except ValueError as ex:\n raise Cmd2ShlexError(ex)\n\n # custom lexing\n tokens = self.split_on_punctuation(tokens)\n return tokens","def tokenize(self, text):\n\n # Normalize text\n text = re.sub(r\"[^a-zA-Z0-9]\", \" \", text.lower())\n\n # Tokenize text\n tokens = word_tokenize(text)\n\n # Remove stop words\n tokens = [t for t in tokens if t not in stopwords.words(\"english\")]\n\n # Lemmatization\n lemmatizer = WordNetLemmatizer()\n # reduce words to their root form using default pos\n tokens = [lemmatizer.lemmatize(t) for t in tokens]\n # lemmatize verbs by specifying pos\n tokens = [lemmatizer.lemmatize(t, pos='v') for t in tokens]\n # lemmatize verbs by specifying pos\n tokens = [lemmatizer.lemmatize(t, pos='a') for t in tokens]\n\n # drop duplicates\n tokens = list(pd.Series(tokens, dtype='object').drop_duplicates().values)\n\n return ' '.join(tokens)","def tokenize_records(records):\r\n contents = map(lambda record: record[constants.TEXT], records)\r\n tokenized_records = [word_tokenize(record.lower()) for record in contents]\r\n lemmatized_records = lemmatize_words(tokenized_records)\r\n lemmatized_words = list()\r\n for lemmatized_record in lemmatized_records:\r\n lemmatized_words.extend(lemmatized_record)\r\n return lemmatized_words","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n \n return clean_tokens","def tokenizer(text):\n for entry in text.split('$$$$\\n'):\n if entry.rstrip():\n lines_stream = deque(entry.split('\\n'))\n else:\n continue\n\n # yield from _molfile(stream=lines_stream)\n for token in _molfile(stream=lines_stream):\n yield token\n\n if len(lines_stream):\n # yield from _sdfile(stream=lines_stream)\n for token in _sdfile(stream=lines_stream):\n yield token\n\n yield EndOfFile()","def tokenize(text):\n\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n \n clean_tokens =[]\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n\n return clean_tokens","def _tokenizer_(data, settings):\n\n input_col = settings['input_col']\n output_col = settings['output_col']\n min_token_length = settings['min_token_length']\n to_lowercase = settings['to_lowercase']\n pattern = settings.get('pattern', r\"(?u)\\b\\w\\w+\\b\")\n frag = settings['id_frag']\n\n token_pattern = re.compile(pattern)\n\n def tokenizer(doc):\n return token_pattern.findall(doc)\n\n result = []\n if len(data) > 0:\n\n for sentence in data[input_col].values:\n tokens = tokenizer(sentence)\n row = []\n for t in tokens:\n if len(t) > min_token_length:\n if to_lowercase:\n row.append(t.lower())\n else:\n row.append(t)\n result.append(row)\n\n else:\n result = np.nan\n\n if output_col in data.columns:\n data.drop([output_col], axis=1, inplace=True)\n\n data[output_col] = result\n\n info = generate_info(data, frag)\n return data, info","def tokenize(self, path):\n assert os.path.exists(path), path\n # Add words to the dictionary\n with open(path, 'r') as f:\n # TODO: joblib\n tokens = 0\n for line in f:\n words = line.split() + ['<eos>']\n tokens += len(words)\n for word in words:\n self.dictionary.add_word(word)\n\n # Tokenize file content\n with open(path, 'r') as f:\n ids = torch.LongTensor(tokens)\n token = 0\n for line in tqdm(f):\n words = line.split() + ['<eos>']\n for word in words:\n ids[token] = self.dictionary.word2idx[word]\n token += 1\n return ids","def transform_line(\n line: Line, mode: Mode, features: Collection[Feature] = ()\n) -> Iterator[Line]:\n if line.is_comment:\n yield line\n return\n\n line_str = line_to_string(line)\n\n ll = mode.line_length\n sn = mode.string_normalization\n string_merge = StringMerger(ll, sn)\n string_paren_strip = StringParenStripper(ll, sn)\n string_split = StringSplitter(ll, sn)\n string_paren_wrap = StringParenWrapper(ll, sn)\n\n transformers: List[Transformer]\n if (\n not line.contains_uncollapsable_type_comments()\n and not line.should_split_rhs\n and not line.magic_trailing_comma\n and (\n is_line_short_enough(line, mode=mode, line_str=line_str)\n or line.contains_unsplittable_type_ignore()\n )\n and not (line.inside_brackets and line.contains_standalone_comments())\n ):\n # Only apply basic string preprocessing, since lines shouldn't be split here.\n if Preview.string_processing in mode:\n transformers = [string_merge, string_paren_strip]\n else:\n transformers = []\n elif line.is_def:\n transformers = [left_hand_split]\n else:\n\n def _rhs(\n self: object, line: Line, features: Collection[Feature], mode: Mode\n ) -> Iterator[Line]:\n \"\"\"Wraps calls to `right_hand_split`.\n\n The calls increasingly `omit` right-hand trailers (bracket pairs with\n content), meaning the trailers get glued together to split on another\n bracket pair instead.\n \"\"\"\n for omit in generate_trailers_to_omit(line, mode.line_length):\n lines = list(right_hand_split(line, mode, features, omit=omit))\n # Note: this check is only able to figure out if the first line of the\n # *current* transformation fits in the line length. This is true only\n # for simple cases. All others require running more transforms via\n # `transform_line()`. This check doesn't know if those would succeed.\n if is_line_short_enough(lines[0], mode=mode):\n yield from lines\n return\n\n # All splits failed, best effort split with no omits.\n # This mostly happens to multiline strings that are by definition\n # reported as not fitting a single line, as well as lines that contain\n # trailing commas (those have to be exploded).\n yield from right_hand_split(line, mode, features=features)\n\n # HACK: nested functions (like _rhs) compiled by mypyc don't retain their\n # __name__ attribute which is needed in `run_transformer` further down.\n # Unfortunately a nested class breaks mypyc too. So a class must be created\n # via type ... https://github.com/mypyc/mypyc/issues/884\n rhs = type(\"rhs\", (), {\"__call__\": _rhs})()\n\n if Preview.string_processing in mode:\n if line.inside_brackets:\n transformers = [\n string_merge,\n string_paren_strip,\n string_split,\n delimiter_split,\n standalone_comment_split,\n string_paren_wrap,\n rhs,\n ]\n else:\n transformers = [\n string_merge,\n string_paren_strip,\n string_split,\n string_paren_wrap,\n rhs,\n ]\n else:\n if line.inside_brackets:\n transformers = [delimiter_split, standalone_comment_split, rhs]\n else:\n transformers = [rhs]\n # It's always safe to attempt hugging of power operations and pretty much every line\n # could match.\n transformers.append(hug_power_op)\n\n for transform in transformers:\n # We are accumulating lines in `result` because we might want to abort\n # mission and return the original line in the end, or attempt a different\n # split altogether.\n try:\n result = run_transformer(line, transform, mode, features, line_str=line_str)\n except CannotTransform:\n continue\n else:\n yield from result\n break\n\n else:\n yield line","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for token in tokens:\n clean_token = lemmatizer.lemmatize(token).lower().strip()\n clean_tokens.append(clean_token)\n \n return clean_tokens","def tokenize(self, path):\n # Convert class 1,2 to 0,1\n # print(\"Convert class 1,2 to 0,1\")\n # Convert class 1,2 to 0,1\n dropped = cropped = 0\n oov_count = 0.\n word_count = 0.\n with open(path, 'r') as f:\n linecount = 0\n lines = []\n tags = []\n for line in f:\n linecount += 1\n if self.max_lines > 1 and linecount >= self.max_lines:\n break\n if self.lowercase:\n words = line.lower().strip().split()\n else:\n words = line.strip().split()\n tag, words = int(words[0]), words[1:]\n\n # if applying BPE\n if self.apply_bpe:\n words = [bp for word in words\n for bp in self.bpemb_en.encode(word)]\n\n if len(words) > self.maxlen:\n cropped += 1\n words = words[:self.maxlen]\n# try:\n# crop_words = words[:maxlen]\n# last_period = max(rindex(crop_words, '.'), rindex(crop_words, '!'), rindex(crop_words, ','))\n# except:\n# last_period = self.maxlen\n# if last_period < 10:\n# print(\"Sentence too short! {}\".format(words))\n# words = words[:last_period]\n if len(words) < 3:\n dropped += 1\n# print(words)\n continue\n words = ['<sos>'] + words\n words += ['<eos>']\n\n # vectorize\n vocab = self.dictionary.word2idx\n unk_idx = vocab['<oov>']\n indices = [vocab[w] if w in vocab else unk_idx for w in words]\n word_count += len(indices)\n oov_count += sum([1 if ii==unk_idx else 0 for ii in indices])\n # add to output list\n lines.append(indices)\n # Convert class 1,2 to 0,1\n # tag = tag - 1\n tags.append(tag)\n # tags = to_class_id(tags)\n print(\"Number of sentences cropped from {}: {} out of {} total, dropped {}. OOV rate {:.3f}\".\n format(path, cropped, linecount, dropped, oov_count/word_count))\n\n return list(zip(tags, lines))","def tokenize_wordchars(lines):\n return","def tokenize(self, path):\n dropped = 0\n with open(path, 'r') as f:\n linecount = 0\n lines = []\n for line in f:\n linecount += 1\n if self.lowercase:\n words = line[:-1].lower().strip().split(\" \")\n else:\n words = line[:-1].strip().split(\" \")\n if len(words) > self.maxlen:\n dropped += 1\n continue\n words = ['<sos>'] + words\n words += ['<eos>']\n # vectorize\n vocab = self.dictionary.word2idx\n unk_idx = vocab['<oov>']\n indices = [vocab[w] if w in vocab else unk_idx for w in words]\n lines.append(indices)\n\n print(\"Number of sentences dropped from {}: {} out of {} total\".\n format(path, dropped, linecount))\n return lines","def tokenize(self, path):\n assert os.path.exists(path)\n # add the start of sentence token\n sentence_sep = [BOS]\n with open(path, 'r') as f:\n sentences = [BOS]\n for sentence in tqdm(f, desc='Processing file: {}'.format(path)):\n sentences += sentence.split() + sentence_sep\n # split into list of tokens\n self.data = sentences","def get_tokens(self, numbered_lines):\n tokens = []\n tokens_append = tokens.append\n\n # simple tokenization: spaces and some punctuation\n splitter = re.compile('[\\\\t =;]+').split\n\n for _line_number, line in numbered_lines:\n line = line.strip()\n if line:\n line = prepare_text_line(line)\n if line :\n line = strip_markup(line)\n if line and line.strip():\n for tok in splitter(line):\n # strip trailing quotes and ignore empties\n tok = tok.strip(\"' \")\n if not tok:\n continue\n # strip trailing colons: why?\n tok = tok.rstrip(':').strip()\n # strip leading @: : why?\n tok = tok.lstrip('@').strip()\n if tok and tok not in (':',):\n tokens_append(tok)\n logger.debug('CopyrightDetector:tokens: ' + repr(tokens))\n return tokens","def tokenize(self, start_pos=0, text=None):\n pass","def split_into_tokens(dataset, delimiter=\"\"):\n pass","def preprocess_sent(sent):\n #tokenized = word_tokenize(sent.lower())\n tokenizer = Tok()\n tokenized = tokenizer.tokenize(sent.lower())\n return tokenized","def tokenize(self, fileid):\n for paragraph in self.corpus.paras(fileids=fileid):\n sents = []\n for sent in sent_tokenize(paragraph, language='russian'):\n words = []\n for word in wordpunct_tokenize(sent):\n token = self.lemmatize(word)\n if not self.is_punct(token) and not self.is_stopword(token):\n\n words.append((token, str(self.morph.parse(word)[0].tag.POS)))\n\n sents.append(words)\n yield sents\n # yield [\n # (word, morph.parse(word)[0].tag.POS)\n # # pos_tag(wordpunct_tokenize(sent), lang='rus')\n # for sent in sent_tokenize(paragraph, language='russian')\n # for word in wordpunct_tokenize(sent)\n # ]\n # yield [\n # pos_tag(wordpunct_tokenize(sent), lang='rus')\n # for sent in sent_tokenize(paragraph, language='russian')\n # ]","def tokenize(self, text):\n # text = convert_to_unicode(text)\n\n output_tokens = []\n for token in split_by_whitespace(text):\n chars = list(token)\n if len(chars) > self.max_input_chars_per_word:\n output_tokens.append(self.unk_token)\n continue\n\n is_bad = False\n start = 0\n sub_tokens = []\n while start < len(chars):\n end = len(chars)\n cur_substr = None\n while start < end:\n substr = \"\".join(chars[start:end])\n if start > 0:\n substr = \"##\" + substr\n if substr in self.vocab:\n cur_substr = substr\n break\n end -= 1\n if cur_substr is None:\n is_bad = True\n break\n sub_tokens.append(cur_substr)\n start = end\n\n if is_bad:\n output_tokens.append(self.unk_token)\n else:\n output_tokens.extend(sub_tokens)\n return output_tokens","def _multiprocess_tokenize(self, num_workers: int):\n\n # While displaying progress bar through tqdm, specify total number of\n # sequences to tokenize, because tqdm won't know in case of pool.imap\n with mp.Pool(num_workers) as pool:\n print(f\"[{self._split}] Tokenizing questions...\")\n _question_tuples = self.questions.items()\n _question_indices = [t[0] for t in _question_tuples]\n _questions = list(\n tqdm(\n pool.imap(word_tokenize, [t[1] for t in _question_tuples]),\n total=len(self.questions)\n )\n )\n self.questions = {\n i: question + [\"?\"] for i, question in\n zip(_question_indices, _questions)\n }\n # Delete variables to free memory.\n del _question_tuples, _question_indices, _questions\n\n print(f\"[{self._split}] Tokenizing answers...\")\n _answer_tuples = self.answers.items()\n _answer_indices = [t[0] for t in _answer_tuples]\n _answers = list(\n tqdm(\n pool.imap(word_tokenize, [t[1] for t in _answer_tuples]),\n total=len(self.answers)\n )\n )\n self.answers = {\n i: answer + [\"?\"] for i, answer in\n zip(_answer_indices, _answers)\n }\n # Delete variables to free memory.\n del _answer_tuples, _answer_indices, _answers\n\n print(f\"[{self._split}] Tokenizing captions...\")\n # Convert dict to separate lists of image_ids and captions.\n _caption_tuples = self.captions.items()\n _image_ids = [t[0] for t in _caption_tuples]\n _captions = list(\n tqdm(\n pool.imap(word_tokenize, [t[1] for t in _caption_tuples]),\n total=(len(_caption_tuples))\n )\n )\n # Convert tokenized captions back to a dict.\n self.captions = {i: c for i, c in zip(_image_ids, _captions)}","def tokenize_text(self, s):\n tokens = []\n # We could just have a \"while s:\" here instead of \"for line: while\n # line:\", but for really large log messages with heavy\n # tokenization, the cost in both performance and memory\n # consumption of the approach taken was atrocious.\n for line in s.replace(\"\\r\\n\", \"\\n\").split(\"\\n\"):\n line = line + \"\\n\"\n while line:\n best_match = best_conv = best_userdata = None\n for test in self._formatters:\n match = test[0].search(line)\n # If we find and match and (a) its our first one, or (b) it\n # matches text earlier than our previous best match, or (c) it\n # matches text at the same location as our previous best match\n # but extends to cover more text than that match, then this is\n # our new best match.\n #\n # Implied here is that when multiple formatters match exactly\n # the same text, the first formatter in the registration list wins.\n if match and (\n (best_match is None)\n or (match.start() < best_match.start())\n or (\n (match.start() == best_match.start())\n and (match.end() > best_match.end())\n )\n ):\n best_match = match\n best_conv = test[1]\n best_userdata = test[2]\n # If we found a match...\n if best_match:\n # ... add any non-matching stuff first, then the matching bit.\n start = best_match.start()\n end = best_match.end()\n if start > 0:\n tokens.append(\n _item(match=line[:start], converter=self.format_text, userdata=None)\n )\n tokens.append(\n _item(match=best_match, converter=best_conv, userdata=best_userdata)\n )\n line = line[end:]\n else:\n # Otherwise, just add the rest of the string.\n tokens.append(_item(match=line, converter=self.format_text, userdata=None))\n line = \"\"\n return ViewVCHtmlFormatterTokens(tokens)","def tokenize(self, input: str) -> List[Tuple[str, int, int]]:\n raise NotImplementedError","def _multiprocess_tokenize(self, num_workers: int):\n\n # While displaying progress bar through tqdm, specify total number of\n # sequences to tokenize, because tqdm won't know in case of pool.imap\n with mp.Pool(num_workers) as pool:\n print(f\"[{self._split}] Tokenizing questions...\")\n _question_tuples = self.questions.items()\n _question_indices = [t[0] for t in _question_tuples]\n _questions = list(\n tqdm(\n pool.imap(word_tokenize, [t[1] for t in _question_tuples]),\n total=len(self.questions),\n )\n )\n self.questions = {\n i: question + [\"?\"]\n for i, question in zip(_question_indices, _questions)\n }\n # Delete variables to free memory.\n del _question_tuples, _question_indices, _questions\n\n print(f\"[{self._split}] Tokenizing answers...\")\n _answer_tuples = self.answers.items()\n _answer_indices = [t[0] for t in _answer_tuples]\n _answers = list(\n tqdm(\n pool.imap(word_tokenize, [t[1] for t in _answer_tuples]),\n total=len(self.answers),\n )\n )\n self.answers = {\n i: answer + [\"?\"] for i, answer in zip(_answer_indices, _answers)\n }\n # Delete variables to free memory.\n del _answer_tuples, _answer_indices, _answers\n\n print(f\"[{self._split}] Tokenizing captions...\")\n # Convert dict to separate lists of image_ids and captions.\n _caption_tuples = self.captions.items()\n _image_ids = [t[0] for t in _caption_tuples]\n _captions = list(\n tqdm(\n pool.imap(word_tokenize, [t[1] for t in _caption_tuples]),\n total=(len(_caption_tuples)),\n )\n )\n # Convert tokenized captions back to a dict.\n self.captions = {i: c for i, c in zip(_image_ids, _captions)}","def tokenize_tag(text):\n return [tok for tok in single_tokenizer(text)]","def tokenize(self, path):\n assert os.path.exists(path)\n # Add words to the dictionary\n with open(path, 'r') as f:\n tokens = 0\n for line in f:\n words = line.split() + ['<eos>']\n tokens += len(words)\n for word in words:\n self.dictionary.add_word(word)\n\n # Tokenize file content\n with open(path, 'r') as f:\n ids = []\n token = 0\n for line in f:\n words = line.split() + ['<eos>']\n for word in words:\n ids.append(self.dictionary.word2idx[word])\n token += 1\n\n return ids","def tokenize_chars(line):\n return","def wordize(lines):\n parser = Parser()\n tokenizer = Tokenizer()\n word_ctr = WordCounter()\n words = []\n for l in lines :\n if (l.rstrip()) :\n statement = parser.parseSentence(l, int(word_ctr))\n token_lists = tokenizer.tokenizeStatement(statement, int(word_ctr))\n for l in token_lists :\n if len(l) > 0 :\n words.append(l)\n word_ctr += 1\n return words","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n clean_tokens = []\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n return clean_tokens","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for token in tokens:\n clean_token = lemmatizer.lemmatize(token).lower().strip()\n clean_tokens.append(clean_token)\n\n return clean_tokens","def _tokenize(self, string):\n self._tokens = []\n\n # Split and strip the input string by newlines\n for token in re.split('(.*)', string):\n if token.strip() != '':\n self._tokens.append(token)","def _whitespace_tokenize_with_offsets(self, input_tensor):\n (values, row_splits, start_offsets, end_offsets) = (\n gen_whitespace_tokenizer_v2.tf_text_whitespace_tokenize_with_offsets_v2(\n input_values=input_tensor, input_config=self._config))\n values = RaggedTensor.from_nested_row_splits(\n flat_values=values,\n nested_row_splits=[row_splits])\n start_offsets = RaggedTensor.from_nested_row_splits(\n flat_values=start_offsets,\n nested_row_splits=[row_splits])\n end_offsets = RaggedTensor.from_nested_row_splits(\n flat_values=end_offsets,\n nested_row_splits=[row_splits])\n return (values, start_offsets, end_offsets)","def tokenize(self, path):\n assert os.path.exists(path)\n # Add words to the dictionary\n with open(path, 'r', encoding=\"utf8\") as f:\n for line in f:\n words = line.split() + ['<eos>']\n for word in words:\n self.dictionary.add_word(word)\n\n # Tokenize file content\n with open(path, 'r', encoding=\"utf8\") as f:\n idss = []\n for line in f:\n words = line.split() + ['<eos>']\n ids = []\n for word in words:\n ids.append(self.dictionary.word2idx[word])\n idss.append(torch.tensor(ids).type(torch.int64))\n ids = torch.cat(idss)\n\n return ids","def span_tokenize_words(self, text):\n\t\tsentences = self.tokenize_sentences(text)\n\t\ttokens_per_sentence = list()\n\t\tsentence_offset = 0\n\t\t\n\t\tsentence_counter = 0\n\t\tfor sentence in sentences:\n\t\t\tsentence_tokens = list()\n\t\t\tfor token in self.word_tokenizer.span_tokenize(sentence):\n\t\t\t\t# save actual token together with it's positions\n\t\t\t\tbegin = token[0] + sentence_offset\n\t\t\t\tend = token[1] + sentence_offset\n\t\t\t\ttoken_tuple = (text[begin:end],begin,end,sentence_counter)\n\t\t\t\tsentence_tokens.append(token_tuple)\n\t\t\t\t\n\t\t\ttokens_per_sentence.append(sentence_tokens)\n\t\t\t\n\t\t\tsentence_counter = sentence_counter + 1\n\t\t\tsentence_offset = sentence_offset + len(sentence) + 1\n\t\t\n\t\treturn tokens_per_sentence","def tokenize(self, input_string: str) -> List[str]:","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n\n return clean_tokens","def split_whitespace_tokens(line):\n in_quote = False\n token = \"\"\n token_start = 0\n for i, char in enumerate(line):\n if char == ' ':\n if len(token) > 0:\n yield (token_start, token)\n token = \"\"\n else:\n if len(token) == 0:\n token_start = i\n token += char\n if len(token) > 0:\n yield (token_start, token)","def tokenize(self, path, training_set=False):\n assert os.path.exists(path)\n with open(path, encoding='utf8') as fin:\n num_lines = sum(1 for _ in fin.readlines())\n with open(path, 'r', encoding=\"utf8\") as f:\n words = []\n for i, line in enumerate(tqdm(f, total=num_lines)):\n if self.max_lines > 0 and i > self.max_lines:\n break\n line = line.strip()\n if not line:\n continue # Skip empty lines.\n elif line.startswith('='):\n continue # Skip headers.\n else:\n sentence = (self.order - 1) * [SOS] + \\\n [process(word, self.lower) for word in line.split()] + [EOS]\n if training_set:\n words.extend(sentence)\n self.vocab.update(sentence)\n else:\n sentence = [word if word in self.vocab else UNK for word in sentence]\n words.extend(sentence)\n return words","def tokenize(self, path):\n assert os.path.exists(path)\n # Add symbol to the dictionary\n with open(path, 'r') as f:\n tokens = 0\n for line in f:\n tokens += len(line)\n for s in line:\n self.dictionary.add_symbol(s)\n\n # Tokenize file content\n with open(path, 'r') as f:\n ids = torch.LongTensor(tokens)\n token = 0\n for line in f:\n for s in line:\n ids[token] = self.dictionary.symbol2idx[s]\n token += 1\n\n return ids","def tokenize(self, path):\n assert os.path.exists(path)\n # Add words to the dictionary\n with open(path, 'r') as f:\n tokens = 0\n for line in f:\n words = line.split() + ['<eos>']\n tokens += len(words)\n for word in words:\n self.dictionary.add_word(word)\n\n # Tokenize file content\n with open(path, 'r') as f:\n ids = torch.LongTensor(tokens)\n token = 0\n for line in f:\n words = line.split() + ['<eos>']\n for word in words:\n ids[token] = self.dictionary.word2idx[word]\n token += 1\n\n return ids","def tokenize(self, path):\n assert os.path.exists(path)\n # Add words to the dictionary\n with open(path, 'r') as f:\n tokens = 0\n for line in f:\n words = line.split() + ['<eos>']\n tokens += len(words)\n for word in words:\n self.dictionary.add_word(word)\n\n # Tokenize file content\n with open(path, 'r') as f:\n ids = torch.LongTensor(tokens)\n token = 0\n for line in f:\n words = line.split() + ['<eos>']\n for word in words:\n ids[token] = self.dictionary.word2idx[word]\n token += 1\n\n return ids","def preprocess(self, sentence, vocab_set=None):\n tokens = sentence.split()\n new_tokens = []\n for token in tokens:\n new_tokens += self.__clean(token)\n tokens = new_tokens\n\n tokens = self.__normalize_document(' '.join(tokens))\n\n return tokens","def tokenize(text):\n\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n return [lemmatizer.lemmatize(token).lower().strip() for token in tokens]","def preprocess(self,text):\n return preprocess.get_tokens(text)","def prepare_data(self, lines: List[str]) -> List[str]:\n if self.is_tokenized:\n if self.parser == \"spacy\":\n lines = [l.split() for l in lines]\n elif self.parser == \"udpipe\":\n lines = [[l.split()] for l in lines]\n\n return lines","def tokenize(self):\n count = 0\n for entry in self._entries:\n token_pairs = []\n for relation in entry['relations']:\n assert len(relation) == 3\n token_pairs.append((relation[0][0],relation[1][0],relation[2][0]))\n\n num_rels = len(entry['relations'])\n num_random_rels = (self._max_seq_length - 2) // 3 - num_rels\n\n if num_random_rels>0:\n pass\n # gt_pairs = {(rel[0],rel[2]) for rel in entry['relations']}\n # random_pairs = self._get_random_pair(entry['objects'], gt_pairs, num_random_rels)\n # for pair in list(random_pairs):\n # token_pairs.append((pair[0][0],'background', pair[1][0]))\n else:\n for i in range(-num_random_rels):\n token_pairs.pop()\n\n random.shuffle(token_pairs)\n tokens = []\n for pair in token_pairs:\n tokens.extend(pair)\n\n tokens = ['[CLS]'] + tokens + ['[SEP]']\n tokens_char = tokens\n\n target = [self._tokenizer.vocab.get(self._tokenizer.tokenize(x)[0], self._tokenizer.vocab['[UNK]']) if i%3==2 else -1 for i, x in enumerate(tokens)]\n tokens = [self._tokenizer.vocab.get(self._tokenizer.tokenize(x)[0], self._tokenizer.vocab['[UNK]']) if i%3!=2 else self._tokenizer.vocab.get('[MASK]', self._tokenizer.vocab['[UNK]']) for i, x in enumerate(tokens)]\n \n for i in range(len(tokens)):\n if target[i] != -1:\n print(tokens_char[i],tokens[i],target[i])\n\n segment_ids = [0] * len(tokens)\n input_mask = [1] * len(tokens)\n # input_mask = [1 if i%3==2 else 0 for i in range(len(tokens))]\n # co_attention_mask = [-1 if i%3==2 else 1 for i in range(len(tokens))]\n # co_attention_mask = torch.zeros((self._max_region_num, self._max_seq_length))\n # co_attention_mask[0] = -1\n # co_attention_mask[-1] = -1\n \n if len(tokens) < self._max_seq_length:\n padding = [self._padding_index] * (self._max_seq_length - len(tokens))\n tokens = tokens + padding\n input_mask += padding\n segment_ids += padding \n target += [-1] * len(padding) \n\n assert_eq(len(tokens), self._max_seq_length)\n entry['input_ids'] = tokens \n entry[\"input_mask\"] = input_mask\n entry['segment_ids'] = segment_ids\n # entry[\"co_attention_mask\"] = co_attention_mask\n entry['target'] = target\n\n sys.stdout.write('%d/%d\\r' % (count, len(self._entries)))\n sys.stdout.flush()\n count += 1"],"string":"[\n \"def tokenize_words(line):\\n return\",\n \"def tokenize(\\n self, text_row: Optional[List[str]], token_row: Optional[List[List[str]]]\\n ):\\n raise NotImplementedError\",\n \"def tokenize_line(line, max_line_length=None, number_token=None, name_token=None, gpe_token=None):\\n new_line = word_tokenize(line,\\n number_token=number_token,\\n name_token=name_token,\\n gpe_token=gpe_token)\\n if max_line_length:\\n new_line = new_line[:max_line_length]\\n new_line = vector_to_string(new_line)\\n return new_line\",\n \"def tokenize(src):\\n\\n pass\",\n \"def tokenize(self, lines):\\n tokens = []\\n\\n for line_number, line in enumerate(lines):\\n self._line_number = line_number + 1\\n self._line = line.rstrip('\\\\r\\\\n')\\n\\n last_end = 0\\n for token in _TOKEN_RE.finditer(self._line):\\n if token.start() != last_end:\\n self.error(\\n 'invalid token',\\n token=Token('INVALID',\\n self._line[last_end:token.start()],\\n self.filename, self._line,\\n self._line_number, last_end))\\n last_end = token.end()\\n\\n # Omit whitespace and comments now to avoid sprinkling this logic\\n # elsewhere.\\n if token.lastgroup in ('WHITESPACE', 'COMMENT',\\n 'CONTINUATION'):\\n continue\\n tokens.append(\\n Token(token.lastgroup, token.group(), self.filename,\\n self._line, self._line_number, token.start()))\\n if last_end != len(self._line):\\n self.error(\\n 'invalid token',\\n token=Token('INVALID', self._line[last_end:],\\n self.filename, self._line, self._line_number,\\n last_end))\\n\\n if self._line.endswith('\\\\\\\\'):\\n # This line is not finished yet.\\n continue\\n\\n if tokens:\\n # Return a copy of the token list so that the caller can be free\\n # to modify it.\\n yield tokens[::]\\n tokens.clear()\",\n \"def tokenize(lines, token='word'):\\n if token == 'word':\\n return [line.split() for line in lines]\\n elif token == 'char':\\n return [list(line) for line in lines]\\n else:\\n print('ERROR: unknown token type: ' + token)\",\n \"def _tokenize_line(self, line: str, pattern='\\\\W'):\\n # TODO check nltk tokenize\\n # TODO check string not to lower\\n line = re.sub(\\\"[.,;:]\\\", \\\" \\\", line)\\n return re.split(pattern, line.lower())\",\n \"def _tokenize(source):\\n lines = source.split(\\\"\\\\n\\\")\\n print(\\n \\\"{type:<10}{string:<25} {start:^12} {end:^12}\\\".format(\\n type=\\\"Type\\\", string=\\\"String\\\", start=\\\"Start\\\", end=\\\"End\\\"\\n )\\n )\\n print(\\\"-\\\" * 60)\\n for line in lines:\\n tokens = collect_tokens(line)\\n for token in tokens:\\n print(token)\",\n \"def tokenize(self, input): # pylint: disable=redefined-builtin\\n (tokens, _, _) = self.tokenize_with_offsets(input)\\n return tokens\",\n \"def tokenise(sample):\\n\\n processed = sample.split()\\n return processed\",\n \"def tokenize(fp):\\n for line in fp:\\n line = line.strip()\\n if line[0] == '#':\\n continue\\n for tok in line.split():\\n yield tok\",\n \"def _batch_tokenize(self, text: List[str]) -> List[List[str]]:\\n return self.bert_model.batch_tokenize([t.strip() for t in text])\",\n \"def tokenize(line):\\n tokens = [x for x in re.split(\\\"[ \\\\f\\\\n\\\\r\\\\t\\\\v,()]+\\\", line) if x]\\n return tokens[0], tokens[1:]\",\n \"def tokenize(self, raw_text):\\n # TODO implement\\n raw_tokens = word_tokenize(raw_text.decode('utf8'))\\n return self.filter_tokens(raw_tokens)\\n # return self.split_by(raw_tokens, '-')\",\n \"def collect_tokens(line):\\n tokens = []\\n try:\\n for tok in tokenize.generate_tokens(StringIO(line).readline):\\n token = Token(tok)\\n if not token.string.strip(): # ignore spaces\\n continue\\n if token.type == tokenize.COMMENT:\\n break\\n tokens.append(token)\\n except tokenize.TokenError:\\n return []\\n except Exception as e:\\n print(\\\"%s raised in utils.collect_tokens\\\" % repr(e))\\n\\n return tokens\",\n \"def tokenize(self, text):\\n text = convert_to_unicode(text)\\n text = self._clean_text(text)\\n\\n # This was added on November 1st, 2018 for the multilingual and Chinese\\n # models. This is also applied to the English models now, but it doesn't\\n # matter since the English models were not trained on any Chinese data\\n # and generally don't have any Chinese data in them (there are Chinese\\n # characters in the vocabulary because Wikipedia does have some Chinese\\n # words in the English Wikipedia.).\\n text = self._tokenize_chinese_chars(text)\\n\\n orig_tokens = whitespace_tokenize(text)\\n split_tokens = []\\n for token in orig_tokens:\\n if self.do_lower_case:\\n token = token.lower()\\n token = self._run_strip_accents(token)\\n if self.split_on_punc:\\n split_tokens.extend(self._run_split_on_punc(token))\\n else:\\n split_tokens.append(token) # pragma: no cover\\n\\n output_tokens = whitespace_tokenize(\\\" \\\".join(split_tokens))\\n return output_tokens\",\n \"def tokenize(line):\\n line = line.strip()\\n tokens = deque()\\n permanent = line.startswith('@')\\n if permanent:\\n line = line[1:]\\n while line:\\n token, line, comment = OrdersParser._get_token(line)\\n if comment:\\n return (tokens, permanent, token)\\n else:\\n tokens.append(token)\\n \\n return (tokens, permanent, None)\",\n \"def tokenize(raw_text):\\n def _xop(tokens):\\n def _(x):\\n return xop(x, \\\"op\\\", tokens)\\n return _\\n \\n raw_tokens=xversa_split(raw_text, tokens=Op_Tokens+Group_Tokens)\\n tokens=map(xtotype, raw_tokens) \\n tokens=map(_xop(Op_Tokens+Group_Tokens), tokens)\\n return tokens\",\n \"def tokenize_wrapper(input):\\n skip = {token.NEWLINE, token.INDENT, token.DEDENT}\\n tokens = tokenize.generate_tokens(io.StringIO(input).readline)\\n for quintuple in tokens:\\n type, value, start, end, line_text = quintuple\\n if type not in skip:\\n yield quintuple\",\n \"def _tokenize(self, text):\\n split_tokens = []\\n for token in self.basic_tokenizer.tokenize(text):\\n for sub_token in self.wordpiece_tokenizer.tokenize(token):\\n split_tokens.append(sub_token)\\n return split_tokens\",\n \"def tokenize(self, text):\\n text = utils.convert_to_unicode(text)\\n text = self._clean_text(text)\\n\\n # This was added on November 1st, 2018 for the multilingual and Chinese\\n # models. This is also applied to the English models now, but it doesn't\\n # matter since the English models were not trained on any Chinese data\\n # and generally don't have any Chinese data in them (there are Chinese\\n # characters in the vocabulary because Wikipedia does have some Chinese\\n # words in the English Wikipedia.).\\n text = self._tokenize_chinese_chars(text)\\n\\n orig_tokens = whitespace_tokenize(text)\\n split_tokens = []\\n for token in orig_tokens:\\n if self.do_lower_case:\\n token = token.lower()\\n token = self._run_strip_accents(token)\\n split_tokens.extend(self._run_split_on_punc(token))\\n\\n output_tokens = whitespace_tokenize(\\\" \\\".join(split_tokens))\\n return output_tokens\",\n \"def _split_to_tokens(self, file_content: str):\\n cur_token = ''\\n string_started = False\\n for line in file_content.split('\\\\n'):\\n cur_token = ''\\n line = line.strip()\\n if line.startswith('#'): # skip comments\\n continue\\n for char in line:\\n if string_started:\\n if char == '\\\"': # string ended\\n self._add_non_empty_token(cur_token)\\n cur_token = '' # start of a new string\\n string_started = False\\n else:\\n cur_token += char\\n elif char == '\\\"':\\n self._add_non_empty_token(cur_token)\\n cur_token = '' # start of a new string\\n string_started = True\\n elif (char == \\\" \\\" and not string_started) or char == '\\\\n':\\n self._add_non_empty_token(cur_token)\\n cur_token = ''\\n elif char in [':', '{', '}', '[', ']', ',']:\\n self._add_non_empty_token(cur_token)\\n self._tokens.append(char)\\n cur_token = ''\\n else:\\n cur_token += char\\n self._add_non_empty_token(cur_token)\\n self._add_non_empty_token(cur_token)\",\n \"def tokenize_line(line, row, col):\\n if len(line) == 0:\\n return []\\n\\n # skip spaces\\n if line[0].isspace():\\n return tokenize_line(line[1:], row, col + 1)\\n\\n # check for comments\\n if line[0] == '#':\\n return []\\n\\n first_token = None\\n\\n # check for the first token\\n for token_type, token_regex, value_func in token_lex_info_list:\\n match = re.match(token_regex, line)\\n if match is not None:\\n uncooked = match.group(0)\\n if first_token is None or\\\\\\n len(first_token.uncooked) < len(uncooked):\\n first_token = Token(type = token_type,\\n value = value_func(uncooked),\\n uncooked = uncooked,\\n location = (row, col))\\n\\n if first_token is None:\\n raise LexerException(\\\"Invalid token\\\", (row, col))\\n else:\\n token_len = len(first_token.uncooked)\\n line_tail = line[token_len:]\\n return [first_token] + tokenize_line(line_tail, row, col + token_len)\",\n \"def basic_tokenizer(line, normalize_digits=True):\\n #returns words: array of tokens\\n #removes <u>, </u>, [, ] from given line\\n line = re.sub('<u>', '', line) #re.sub is regex\\n line = re.sub('</u>', '', line)\\n line = re.sub('\\\\[', '', line)\\n line = re.sub('\\\\]', '', line)\\n words = []\\n #re.compiles a regex into a regex object so match or search can be used\\n #python 3: b\\\"\\\" turns string into \\\"bytes literal\\\" which turns string into byte. Ignored in Python 2\\n #r string prefix is raw string: '\\\\n' is \\\\,n instead of newline\\n _WORD_SPLIT = re.compile(b\\\"([.,!?\\\\\\\"'-<>:;)(])\\\") #includes () for re.split below\\n _DIGIT_RE = re.compile(r\\\"\\\\d\\\")\\n #strip removes whitespace at beginning and end\\n #lowercase string\\n for fragment in line.strip().lower().split(): #each of these is a fragment ['you,', 'are', 'here!']\\n for token in re.split(_WORD_SPLIT, fragment): #each token splits each fragment i.e. each token in ['here', '!']\\n if not token: #if empty array\\n continue\\n if normalize_digits: #substitutes digits with #\\n token = re.sub(_DIGIT_RE, b'#', token)\\n words.append(token)\\n return words\",\n \"def tokeneater(self, toktype, toktext, (srow,scol), (erow,ecol), line):\\n # If we encounter any errors, then just give up.\\n if toktype == token.ERRORTOKEN:\\n raise tokenize.TokenError, toktype\\n\\n # Did we skip anything whitespace? If so, add a pseudotoken\\n # for it, with toktype=None. (Note -- this skipped string\\n # might also contain continuation slashes; but I won't bother\\n # to colorize them.)\\n startpos = self.line_offsets[srow] + scol\\n if startpos > self.pos:\\n skipped = self.text[self.pos:startpos]\\n self.cur_line.append( (None, skipped) )\\n\\n # Update our position.\\n self.pos = startpos + len(toktext)\\n\\n # Update our current line.\\n self.cur_line.append( (toktype, toktext) )\\n\\n # When we reach the end of a line, process it.\\n if toktype == token.NEWLINE or toktype == token.ENDMARKER:\\n self.handle_line(self.cur_line)\\n self.cur_line = []\",\n \"def tokenize(self, text):\\n text = convert_to_unicode(text)\\n text = self.clean_text(text)\\n\\n # This was added on November 1st, 2018 for the multilingual and Chinese\\n # models. This is also applied to the English models now, but it doesn't\\n # matter since the English models were not trained on any Chinese data\\n # and generally don't have any Chinese data in them (there are Chinese\\n # characters in the vocabulary because Wikipedia does have some Chinese\\n # words in the English Wikipedia.).\\n text = self._add_space_around_cjk_chars(text)\\n\\n orig_tokens = split_by_whitespace(text)\\n split_tokens = []\\n for token in orig_tokens:\\n if self.do_lower_case:\\n token = token.lower()\\n token = remove_accents(token)\\n split_tokens.extend(split_by_punctuation(token))\\n\\n output_tokens = split_by_whitespace(\\\" \\\".join(split_tokens))\\n return output_tokens\",\n \"def tokenize(text):\\n sentence = Sentence(text)\\n return sentence.tokens()\",\n \"def tokenize(text, token):\\n text = [token(x) for x in text]\\n return text\",\n \"def line2Token(linein):\\n#\\t\\\"\\\"\\\" input=readlines() output=token\\\"\\\"\\n\\tlistout = []\\n\\tfor s in linein:\\n\\t\\tif s==\\\"\\\":\\n\\t\\t\\tcontinue\\n\\t\\ts = string.replace(s,'\\\\n','')\\n\\t\\ts = string.replace(s,',',' ')\\n s = string.replace(s,'=',\\\"= \\\")\\n\\t\\ts = string.replace(s,':',\\\": \\\")\\n\\n\\t\\tlista=string.split(s)\\n\\t\\tfor x in lista:\\n\\t\\t\\tif x<>\\\"\\\":\\n\\t\\t\\t\\tlistout.append(x)\\n\\n\\treturn listout\",\n \"def tokenize(\\n tokenizer: Tokenizer,\\n lines: typing.Iterable[str],\\n language: typing.Optional[str] = None,\\n is_csv: bool = False,\\n csv_delimiter: str = \\\"|\\\",\\n split_sentences: bool = False,\\n inline_pronunciations: bool = False,\\n) -> typing.Iterable[typing.Dict[str, typing.Any]]:\\n # String used to join tokens.\\n # See RegexTokenizer\\n join_str: str = getattr(tokenizer, \\\"join_str\\\", \\\" \\\")\\n\\n if inline_pronunciations:\\n assert language is not None\\n lang_phonemes = gruut_ipa.Phonemes.from_language(language)\\n assert lang_phonemes is not None, f\\\"Unsupported language {language}\\\"\\n\\n def process_lines(lines):\\n for line in lines:\\n yield encode_inline_pronunciations(line, lang_phonemes)\\n\\n lines = process_lines(lines)\\n\\n for line in lines:\\n line = line.strip()\\n if not line:\\n continue\\n\\n utt_id = \\\"\\\"\\n\\n if is_csv:\\n # Input format is id|text\\n utt_id, line = line.split(csv_delimiter, maxsplit=1)\\n\\n sentences = list(tokenizer.tokenize(line))\\n\\n if split_sentences:\\n # One output line per sentence\\n for sentence_idx, sentence in enumerate(sentences):\\n sentence_id = str(sentence_idx)\\n if utt_id:\\n sentence_id = f\\\"{utt_id}_{sentence_id}\\\"\\n\\n yield {\\n \\\"id\\\": sentence_id,\\n \\\"raw_text\\\": sentence.raw_text,\\n \\\"raw_words\\\": sentence.raw_words,\\n \\\"clean_words\\\": sentence.clean_words,\\n \\\"tokens\\\": [dataclasses.asdict(t) for t in sentence.tokens],\\n \\\"clean_text\\\": sentence.clean_text,\\n \\\"sentences\\\": [],\\n }\\n else:\\n # One output line per input line\\n raw_words: typing.List[str] = []\\n clean_words: typing.List[str] = []\\n tokens: typing.List[Token] = []\\n\\n for sentence in sentences:\\n raw_words.extend(sentence.raw_words)\\n clean_words.extend(sentence.clean_words)\\n tokens.extend(sentence.tokens)\\n\\n yield {\\n \\\"id\\\": utt_id,\\n \\\"raw_text\\\": line,\\n \\\"raw_words\\\": raw_words,\\n \\\"clean_words\\\": clean_words,\\n \\\"tokens\\\": [dataclasses.asdict(t) for t in tokens],\\n \\\"clean_text\\\": join_str.join(clean_words),\\n \\\"sentences\\\": [dataclasses.asdict(s) for s in sentences],\\n }\",\n \"def tokenize(self, rawt):\\n def createtokens(rawt):\\n for oper in self.control.sortedopers:\\n if oper in rawt:\\n par = rawt.partition(oper)\\n return createtokens(par[0]) + [par[1]] + createtokens(par[2])\\n for punc in self.control.punctuation:\\n if punc in rawt:\\n par = rawt.partition(punc)\\n return createtokens(par[0]) + [par[1]] + createtokens(par[2])\\n return [rawt]\\n tokens = [token for token in createtokens(rawt) if token]\\n ret = []\\n currentquote = None\\n for token in tokens:\\n if token in self.control.allquotes and token:\\n if currentquote == None:\\n ret.append(token)\\n currentquote = token\\n else:\\n if token == currentquote:\\n currentquote = None\\n ret[-1] += token\\n elif currentquote:\\n ret[-1] += token\\n else:\\n ret.append(token)\\n #@define stuff\\n linep = 0\\n while linep < len(ret): \\n if ret[linep] and ret[linep] in self.control.datadef:\\n self.control.applyrules(ret.args.pop(0))\\n linep+=1\\n ret2 = []\\n for token in ret:\\n if token:\\n if token[0] not in self.control.allquotes:\\n if token.strip(self.control.nbwhitespace):\\n if __debug__:\\n assert token[-1] not in self.control.allquotes, token\\n ret2.append(token.strip(self.control.nbwhitespace))\\n else:\\n ret2.append(token)\\n\\n ret = []\\n for e in (e.strip(self.control.nbwhitespace) for e in ret2):\\n if not ret or not e or e not in self.control.delims['endline']\\\\\\n or str(ret[-1].data) not in self.control.delims['endline']:\\n ret.append(group(e, control = self.control))\\n # quit(list(str(x) for x in ret))\\n return ret\\n # return [group(e, control = self.control) for e in (e.strip(self.control.nbwhitespace) for e in ret2) if e]\",\n \"def tokenize(text):\\n return text.split(' ')\",\n \"def basic_tokenizer(line, normalize_digits=True):\\n line = re.sub(b'<u>', b'', line)\\n line = re.sub(b'</u>', b'', line)\\n line = re.sub(br'\\\\[', b'', line)\\n line = re.sub(br'\\\\]', b'', line)\\n words = []\\n _WORD_SPLIT = re.compile(b\\\"([.,!?\\\\\\\"'-<>:;)(])\\\")\\n _DIGIT_RE = re.compile(br\\\"\\\\d\\\")\\n for fragment in line.strip().lower().split():\\n for token in re.split(_WORD_SPLIT, fragment):\\n if not token:\\n continue\\n if normalize_digits:\\n token = re.sub(_DIGIT_RE, b'#', token)\\n words.append(token)\\n return words\",\n \"def tokenize(self, text):\\n text = self._clean_text(text)\\n text = self._tokenize_chinese_chars(text)\\n orig_tokens = whitespace_tokenize(text)\\n split_tokens = []\\n for token in orig_tokens:\\n if self.do_lower_case and token not in self.never_split:\\n token = token.lower()\\n token = self._run_strip_accents(token)\\n split_tokens.extend(self._run_split_on_punc(token))\\n output_tokens = whitespace_tokenize(' '.join(split_tokens))\\n return output_tokens\",\n \"def lex(lines):\\n for line in lines:\\n yield line.rstrip()\",\n \"def _tokenize(self, text: str) -> List[str]:\\n return self.bert_model.tokenize(text.strip())\",\n \"def tokenize(fp):\\n\\n tokenizer = Tokenizer()\\n\\n for (lineno, line) in enumerate(fp):\\n try:\\n line = line.decode('utf8')\\n except UnicodeDecodeError as detail:\\n print >>sys.stderr, \\\"failed to decode line %i: %s\\\" % (lineno+1,\\n detail)\\n line = line.decode('utf8', 'replace')\\n\\n # This should use \\\"yield from ...\\\" (new in Python 3.3)\\n for t in tokenizer.feed_data(line):\\n yield t\\n last = tokenizer.finalize()\\n if last:\\n yield last\",\n \"def tokenize(self, text):\\n # Ignore non-ASCII characters.\\n text = remove_non_ascii(text)\\n text = text.translate(Tokenizer.trans)\\n tokens = [t for t in text.split() \\n if len(t) >= self._config[u'min_len']\\n and t not in self._config[u'stopwords']]\\n self._counter.update(tokens)\",\n \"def tokenize_with_offsets(self, input): # pylint: disable=redefined-builtin\\n name = None\\n with ops.name_scope(name, \\\"WhitespaceTokenize\\\", [input]):\\n input_tensor = ragged_tensor.convert_to_tensor_or_ragged_tensor(input)\\n if input_tensor.shape.ndims is None:\\n raise ValueError(\\\"Rank of input_tensor must be statically known.\\\")\\n if ragged_tensor.is_ragged(input_tensor):\\n if input_tensor.flat_values.shape.ndims > 1:\\n # If the flat_values of our ragged tensor is multi-dimensional, we can\\n # process it separately and our output will have the same nested\\n # splits as our input.\\n (tokens, starts,\\n ends) = self.tokenize_with_offsets(input_tensor.flat_values)\\n return (input_tensor.with_flat_values(tokens),\\n input_tensor.with_flat_values(starts),\\n input_tensor.with_flat_values(ends))\\n else:\\n # Recursively process the values of the ragged tensor.\\n (tokens, starts,\\n ends) = self.tokenize_with_offsets(input_tensor.values)\\n return (input_tensor.with_values(tokens),\\n input_tensor.with_values(starts),\\n input_tensor.with_values(ends))\\n else:\\n if input_tensor.shape.ndims > 1:\\n # Convert the input tensor to ragged and process it.\\n return self.tokenize_with_offsets(\\n ragged_conversion_ops.from_tensor(input_tensor))\\n elif input_tensor.shape.ndims == 0:\\n (tokens, starts, ends) = self.tokenize_with_offsets(\\n array_ops_stack.stack([input_tensor]))\\n return tokens.values, starts.values, ends.values\\n else:\\n # Our rank 1 tensor is the correct shape, so we can process it as\\n # normal.\\n return self._whitespace_tokenize_with_offsets(input_tensor)\",\n \"def tokenise(line):\\n\\n sline = str(line)\\n tokens = []\\n token = False\\n quote = False\\n tquote = \\\"\\\"\\n start = 0\\n for i in range(len(sline)):\\n c = sline[i]\\n if token and not quote:\\n if c == \\\" \\\" or c == \\\"\\\\t\\\" or c == \\\"\\\\n\\\":\\n # end of current token\\n tokens.append(sline[start:i])\\n token = False\\n quote = False\\n if token and (c == '\\\"' or c == \\\"'\\\"):\\n # Detected a quote - flip the quote flag\\n if quote:\\n if c == tquote:\\n quote = False\\n else:\\n quote = True\\n tquote = c\\n if not token:\\n if c != \\\" \\\" and c != \\\"\\\\t\\\" and c != \\\"\\\\n\\\":\\n # Start of a new token\\n token = True\\n start = i\\n if c == '\\\"' or c == \\\"'\\\":\\n # Also it's quoted\\n quote = True\\n tquote = c\\n\\n # End of the loop\\n if token:\\n # End of the last token\\n tokens.append(sline[start : len(sline)])\\n return tokens\",\n \"def tokenize(self):\\n\\n self.feats = {\\n 'features': [], # Lists of the `InputFeatures` objects.\\n 'segments': [], # Segments of the phrase. 0: Promoun, 1: A-term, 2: B-term \\n 'df_ids': [], # DataFrame index.\\n 'target_token_ids': [] # Indexes of the target term in the tokens lists.\\n }\\n unique_id = 0 # Unique ID of the dataset.\\n for _, row in tqdm(self.df.iterrows()):\\n segment_tokens = self.tokenize_single_row(row)\\n for j, segment in enumerate(segment_tokens):\\n if segment['target_token_index'] > 0:\\n features = self.tokens_to_features(unique_id, segment['tokens'])\\n unique_id += 1\\n self.feats['features'].append(features)\\n self.feats['segments'].append(j)\\n self.feats['target_token_ids'].append(segment['target_token_index'] )\\n self.feats['df_ids'].append(row.ID)\",\n \"def tokenize(tokenizer, max_length, stride, row):\\r\\n # The input data must be tokenized in the order dictated by the side the\\r\\n # selected checkpoint apply the padding\\r\\n pad_on_right = tokenizer.padding_side == \\\"right\\\"\\r\\n \\r\\n return tokenizer(\\r\\n row[\\\"question\\\" if pad_on_right else \\\"context\\\"],\\r\\n row[\\\"context\\\" if pad_on_right else \\\"question\\\"],\\r\\n max_length=max_length,\\r\\n truncation=\\\"only_second\\\" if pad_on_right else \\\"only_first\\\",\\r\\n return_overflowing_tokens=True,\\r\\n return_offsets_mapping=True,\\r\\n stride=stride,\\r\\n padding=\\\"max_length\\\",\\r\\n )\",\n \"def preprocess_lines(movie_line):\\n\\ttokens = tokenizer.tokenize(movie_line)\\n\\twords = [word for word in tokens if word not in stopwords_set]\\n\\tstemmed_terms = [porter_stemmer.stem(word) for word in words]\\n\\tlemmatized_terms = [wordnet_lemmatizer.lemmatize(word) for word in stemmed_terms]\\n\\treturn lemmatized_terms\",\n \"def identity_tokenizer(text):\\n return text\",\n \"def tokenize(self, path):\\n assert os.path.exists(path)\\n with open(path, 'r') as f:\\n sentences = []\\n for sentence in tqdm(f, desc='Processing file: {}'.format(path)):\\n sentences.append(sentence.split())\\n self.data = sentences\",\n \"def process_line(line):\\n [label, text] = line.split('\\\\t')\\n return text.split()\",\n \"def tokenize(text):\\n source = list(text.rstrip().replace('\\\\n', ' '))\\n return source\",\n \"def tokenize(self, text):\\n return self._tokenize(text)\",\n \"def _tokenize(self, text: str) -> List[str]:\\n text = text.lower().strip()\\n return self.bpe.tokenize(text)\",\n \"def get_tokens(line: str) -> Generator[str, None, None]:\\n for token in line.rstrip().split():\\n if len(token) > 0:\\n yield token\",\n \"def _tokenize(self, text: str) -> List[str]:\\n return self.bpe.tokenize(text)\",\n \"def tokenize(lines):\\n\\tfor line in lines:\\n\\t\\tif line == '':\\n\\t\\t\\tcontinue\\n\\t\\t\\n\\t\\tif line.startswith('#'):\\n\\t\\t\\tcontinue\\n\\n\\t\\tif line.startswith('[') and line.endswith(']'):\\n\\t\\t\\tyield ('key', line[1:-1])\\n\\t\\t\\tcontinue\\n\\t\\t\\n\\t\\tvalues = tuple(map(float, line.split(' ')))\\n\\t\\tyield ('values', values)\\n\\t\\tcontinue\",\n \"def tokenize(self, path, build_dict=False, thd=0):\\n\\n assert os.path.exists(path)\\n\\n if build_dict:\\n # Add words to the dictionary\\n with open(path, 'r') as f:\\n for line in f:\\n words = line.split()\\n for word in words:\\n self.dictionary.add_word(word)\\n if thd > 1:\\n self.dictionary.rebuild_by_freq(thd)\\n\\n # Tokenize file content\\n ids_list = []\\n with open(path, 'r') as f:\\n for line in f:\\n words = line.split()\\n ids = []\\n for word in words:\\n ids.append(self.dictionary[word])\\n ids_list.append(ids)\\n\\n return ids_list\",\n \"def preprocess_file_to_tokens(self, dirPath, fnx):\\n fnxPath = os.path.join(dirPath, fnx)\\n with open(fnxPath) as f:\\n fnx_data = f.read()\\n fnx_data_nnl = re.sub(r'\\\\n', ' ', fnx_data)\\n fnx_data_sb = re.sub(r\\\"( )+\\\", ' ', fnx_data_nnl)\\n\\n fnx_tokens = nltk.word_tokenize(fnx_data_sb)\\n fnx_unk, fnx_tokens_prepped = self.infreq_to_UNK(fnx_tokens)\\n \\n return fnx_tokens_prepped\",\n \"def tokenize(text):\\n tokens=word_tokenize(text)\\n lemmatizer=WordNetLemmatizer()\\n \\n clean_tokens=[]\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n return clean_tokens\\n pass\",\n \"def tokenize(self, line: str) -> List[str]:\\n\\n # expand shortcuts and aliases\\n line = self._expand(line)\\n\\n # check if this line is a comment\\n if line.lstrip().startswith(constants.COMMENT_CHAR):\\n return []\\n\\n # split on whitespace\\n try:\\n tokens = shlex_split(line)\\n except ValueError as ex:\\n raise Cmd2ShlexError(ex)\\n\\n # custom lexing\\n tokens = self.split_on_punctuation(tokens)\\n return tokens\",\n \"def tokenize(self, text):\\n\\n # Normalize text\\n text = re.sub(r\\\"[^a-zA-Z0-9]\\\", \\\" \\\", text.lower())\\n\\n # Tokenize text\\n tokens = word_tokenize(text)\\n\\n # Remove stop words\\n tokens = [t for t in tokens if t not in stopwords.words(\\\"english\\\")]\\n\\n # Lemmatization\\n lemmatizer = WordNetLemmatizer()\\n # reduce words to their root form using default pos\\n tokens = [lemmatizer.lemmatize(t) for t in tokens]\\n # lemmatize verbs by specifying pos\\n tokens = [lemmatizer.lemmatize(t, pos='v') for t in tokens]\\n # lemmatize verbs by specifying pos\\n tokens = [lemmatizer.lemmatize(t, pos='a') for t in tokens]\\n\\n # drop duplicates\\n tokens = list(pd.Series(tokens, dtype='object').drop_duplicates().values)\\n\\n return ' '.join(tokens)\",\n \"def tokenize_records(records):\\r\\n contents = map(lambda record: record[constants.TEXT], records)\\r\\n tokenized_records = [word_tokenize(record.lower()) for record in contents]\\r\\n lemmatized_records = lemmatize_words(tokenized_records)\\r\\n lemmatized_words = list()\\r\\n for lemmatized_record in lemmatized_records:\\r\\n lemmatized_words.extend(lemmatized_record)\\r\\n return lemmatized_words\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n \\n return clean_tokens\",\n \"def tokenizer(text):\\n for entry in text.split('$$$$\\\\n'):\\n if entry.rstrip():\\n lines_stream = deque(entry.split('\\\\n'))\\n else:\\n continue\\n\\n # yield from _molfile(stream=lines_stream)\\n for token in _molfile(stream=lines_stream):\\n yield token\\n\\n if len(lines_stream):\\n # yield from _sdfile(stream=lines_stream)\\n for token in _sdfile(stream=lines_stream):\\n yield token\\n\\n yield EndOfFile()\",\n \"def tokenize(text):\\n\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n \\n clean_tokens =[]\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n\\n return clean_tokens\",\n \"def _tokenizer_(data, settings):\\n\\n input_col = settings['input_col']\\n output_col = settings['output_col']\\n min_token_length = settings['min_token_length']\\n to_lowercase = settings['to_lowercase']\\n pattern = settings.get('pattern', r\\\"(?u)\\\\b\\\\w\\\\w+\\\\b\\\")\\n frag = settings['id_frag']\\n\\n token_pattern = re.compile(pattern)\\n\\n def tokenizer(doc):\\n return token_pattern.findall(doc)\\n\\n result = []\\n if len(data) > 0:\\n\\n for sentence in data[input_col].values:\\n tokens = tokenizer(sentence)\\n row = []\\n for t in tokens:\\n if len(t) > min_token_length:\\n if to_lowercase:\\n row.append(t.lower())\\n else:\\n row.append(t)\\n result.append(row)\\n\\n else:\\n result = np.nan\\n\\n if output_col in data.columns:\\n data.drop([output_col], axis=1, inplace=True)\\n\\n data[output_col] = result\\n\\n info = generate_info(data, frag)\\n return data, info\",\n \"def tokenize(self, path):\\n assert os.path.exists(path), path\\n # Add words to the dictionary\\n with open(path, 'r') as f:\\n # TODO: joblib\\n tokens = 0\\n for line in f:\\n words = line.split() + ['<eos>']\\n tokens += len(words)\\n for word in words:\\n self.dictionary.add_word(word)\\n\\n # Tokenize file content\\n with open(path, 'r') as f:\\n ids = torch.LongTensor(tokens)\\n token = 0\\n for line in tqdm(f):\\n words = line.split() + ['<eos>']\\n for word in words:\\n ids[token] = self.dictionary.word2idx[word]\\n token += 1\\n return ids\",\n \"def transform_line(\\n line: Line, mode: Mode, features: Collection[Feature] = ()\\n) -> Iterator[Line]:\\n if line.is_comment:\\n yield line\\n return\\n\\n line_str = line_to_string(line)\\n\\n ll = mode.line_length\\n sn = mode.string_normalization\\n string_merge = StringMerger(ll, sn)\\n string_paren_strip = StringParenStripper(ll, sn)\\n string_split = StringSplitter(ll, sn)\\n string_paren_wrap = StringParenWrapper(ll, sn)\\n\\n transformers: List[Transformer]\\n if (\\n not line.contains_uncollapsable_type_comments()\\n and not line.should_split_rhs\\n and not line.magic_trailing_comma\\n and (\\n is_line_short_enough(line, mode=mode, line_str=line_str)\\n or line.contains_unsplittable_type_ignore()\\n )\\n and not (line.inside_brackets and line.contains_standalone_comments())\\n ):\\n # Only apply basic string preprocessing, since lines shouldn't be split here.\\n if Preview.string_processing in mode:\\n transformers = [string_merge, string_paren_strip]\\n else:\\n transformers = []\\n elif line.is_def:\\n transformers = [left_hand_split]\\n else:\\n\\n def _rhs(\\n self: object, line: Line, features: Collection[Feature], mode: Mode\\n ) -> Iterator[Line]:\\n \\\"\\\"\\\"Wraps calls to `right_hand_split`.\\n\\n The calls increasingly `omit` right-hand trailers (bracket pairs with\\n content), meaning the trailers get glued together to split on another\\n bracket pair instead.\\n \\\"\\\"\\\"\\n for omit in generate_trailers_to_omit(line, mode.line_length):\\n lines = list(right_hand_split(line, mode, features, omit=omit))\\n # Note: this check is only able to figure out if the first line of the\\n # *current* transformation fits in the line length. This is true only\\n # for simple cases. All others require running more transforms via\\n # `transform_line()`. This check doesn't know if those would succeed.\\n if is_line_short_enough(lines[0], mode=mode):\\n yield from lines\\n return\\n\\n # All splits failed, best effort split with no omits.\\n # This mostly happens to multiline strings that are by definition\\n # reported as not fitting a single line, as well as lines that contain\\n # trailing commas (those have to be exploded).\\n yield from right_hand_split(line, mode, features=features)\\n\\n # HACK: nested functions (like _rhs) compiled by mypyc don't retain their\\n # __name__ attribute which is needed in `run_transformer` further down.\\n # Unfortunately a nested class breaks mypyc too. So a class must be created\\n # via type ... https://github.com/mypyc/mypyc/issues/884\\n rhs = type(\\\"rhs\\\", (), {\\\"__call__\\\": _rhs})()\\n\\n if Preview.string_processing in mode:\\n if line.inside_brackets:\\n transformers = [\\n string_merge,\\n string_paren_strip,\\n string_split,\\n delimiter_split,\\n standalone_comment_split,\\n string_paren_wrap,\\n rhs,\\n ]\\n else:\\n transformers = [\\n string_merge,\\n string_paren_strip,\\n string_split,\\n string_paren_wrap,\\n rhs,\\n ]\\n else:\\n if line.inside_brackets:\\n transformers = [delimiter_split, standalone_comment_split, rhs]\\n else:\\n transformers = [rhs]\\n # It's always safe to attempt hugging of power operations and pretty much every line\\n # could match.\\n transformers.append(hug_power_op)\\n\\n for transform in transformers:\\n # We are accumulating lines in `result` because we might want to abort\\n # mission and return the original line in the end, or attempt a different\\n # split altogether.\\n try:\\n result = run_transformer(line, transform, mode, features, line_str=line_str)\\n except CannotTransform:\\n continue\\n else:\\n yield from result\\n break\\n\\n else:\\n yield line\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for token in tokens:\\n clean_token = lemmatizer.lemmatize(token).lower().strip()\\n clean_tokens.append(clean_token)\\n \\n return clean_tokens\",\n \"def tokenize(self, path):\\n # Convert class 1,2 to 0,1\\n # print(\\\"Convert class 1,2 to 0,1\\\")\\n # Convert class 1,2 to 0,1\\n dropped = cropped = 0\\n oov_count = 0.\\n word_count = 0.\\n with open(path, 'r') as f:\\n linecount = 0\\n lines = []\\n tags = []\\n for line in f:\\n linecount += 1\\n if self.max_lines > 1 and linecount >= self.max_lines:\\n break\\n if self.lowercase:\\n words = line.lower().strip().split()\\n else:\\n words = line.strip().split()\\n tag, words = int(words[0]), words[1:]\\n\\n # if applying BPE\\n if self.apply_bpe:\\n words = [bp for word in words\\n for bp in self.bpemb_en.encode(word)]\\n\\n if len(words) > self.maxlen:\\n cropped += 1\\n words = words[:self.maxlen]\\n# try:\\n# crop_words = words[:maxlen]\\n# last_period = max(rindex(crop_words, '.'), rindex(crop_words, '!'), rindex(crop_words, ','))\\n# except:\\n# last_period = self.maxlen\\n# if last_period < 10:\\n# print(\\\"Sentence too short! {}\\\".format(words))\\n# words = words[:last_period]\\n if len(words) < 3:\\n dropped += 1\\n# print(words)\\n continue\\n words = ['<sos>'] + words\\n words += ['<eos>']\\n\\n # vectorize\\n vocab = self.dictionary.word2idx\\n unk_idx = vocab['<oov>']\\n indices = [vocab[w] if w in vocab else unk_idx for w in words]\\n word_count += len(indices)\\n oov_count += sum([1 if ii==unk_idx else 0 for ii in indices])\\n # add to output list\\n lines.append(indices)\\n # Convert class 1,2 to 0,1\\n # tag = tag - 1\\n tags.append(tag)\\n # tags = to_class_id(tags)\\n print(\\\"Number of sentences cropped from {}: {} out of {} total, dropped {}. OOV rate {:.3f}\\\".\\n format(path, cropped, linecount, dropped, oov_count/word_count))\\n\\n return list(zip(tags, lines))\",\n \"def tokenize_wordchars(lines):\\n return\",\n \"def tokenize(self, path):\\n dropped = 0\\n with open(path, 'r') as f:\\n linecount = 0\\n lines = []\\n for line in f:\\n linecount += 1\\n if self.lowercase:\\n words = line[:-1].lower().strip().split(\\\" \\\")\\n else:\\n words = line[:-1].strip().split(\\\" \\\")\\n if len(words) > self.maxlen:\\n dropped += 1\\n continue\\n words = ['<sos>'] + words\\n words += ['<eos>']\\n # vectorize\\n vocab = self.dictionary.word2idx\\n unk_idx = vocab['<oov>']\\n indices = [vocab[w] if w in vocab else unk_idx for w in words]\\n lines.append(indices)\\n\\n print(\\\"Number of sentences dropped from {}: {} out of {} total\\\".\\n format(path, dropped, linecount))\\n return lines\",\n \"def tokenize(self, path):\\n assert os.path.exists(path)\\n # add the start of sentence token\\n sentence_sep = [BOS]\\n with open(path, 'r') as f:\\n sentences = [BOS]\\n for sentence in tqdm(f, desc='Processing file: {}'.format(path)):\\n sentences += sentence.split() + sentence_sep\\n # split into list of tokens\\n self.data = sentences\",\n \"def get_tokens(self, numbered_lines):\\n tokens = []\\n tokens_append = tokens.append\\n\\n # simple tokenization: spaces and some punctuation\\n splitter = re.compile('[\\\\\\\\t =;]+').split\\n\\n for _line_number, line in numbered_lines:\\n line = line.strip()\\n if line:\\n line = prepare_text_line(line)\\n if line :\\n line = strip_markup(line)\\n if line and line.strip():\\n for tok in splitter(line):\\n # strip trailing quotes and ignore empties\\n tok = tok.strip(\\\"' \\\")\\n if not tok:\\n continue\\n # strip trailing colons: why?\\n tok = tok.rstrip(':').strip()\\n # strip leading @: : why?\\n tok = tok.lstrip('@').strip()\\n if tok and tok not in (':',):\\n tokens_append(tok)\\n logger.debug('CopyrightDetector:tokens: ' + repr(tokens))\\n return tokens\",\n \"def tokenize(self, start_pos=0, text=None):\\n pass\",\n \"def split_into_tokens(dataset, delimiter=\\\"\\\"):\\n pass\",\n \"def preprocess_sent(sent):\\n #tokenized = word_tokenize(sent.lower())\\n tokenizer = Tok()\\n tokenized = tokenizer.tokenize(sent.lower())\\n return tokenized\",\n \"def tokenize(self, fileid):\\n for paragraph in self.corpus.paras(fileids=fileid):\\n sents = []\\n for sent in sent_tokenize(paragraph, language='russian'):\\n words = []\\n for word in wordpunct_tokenize(sent):\\n token = self.lemmatize(word)\\n if not self.is_punct(token) and not self.is_stopword(token):\\n\\n words.append((token, str(self.morph.parse(word)[0].tag.POS)))\\n\\n sents.append(words)\\n yield sents\\n # yield [\\n # (word, morph.parse(word)[0].tag.POS)\\n # # pos_tag(wordpunct_tokenize(sent), lang='rus')\\n # for sent in sent_tokenize(paragraph, language='russian')\\n # for word in wordpunct_tokenize(sent)\\n # ]\\n # yield [\\n # pos_tag(wordpunct_tokenize(sent), lang='rus')\\n # for sent in sent_tokenize(paragraph, language='russian')\\n # ]\",\n \"def tokenize(self, text):\\n # text = convert_to_unicode(text)\\n\\n output_tokens = []\\n for token in split_by_whitespace(text):\\n chars = list(token)\\n if len(chars) > self.max_input_chars_per_word:\\n output_tokens.append(self.unk_token)\\n continue\\n\\n is_bad = False\\n start = 0\\n sub_tokens = []\\n while start < len(chars):\\n end = len(chars)\\n cur_substr = None\\n while start < end:\\n substr = \\\"\\\".join(chars[start:end])\\n if start > 0:\\n substr = \\\"##\\\" + substr\\n if substr in self.vocab:\\n cur_substr = substr\\n break\\n end -= 1\\n if cur_substr is None:\\n is_bad = True\\n break\\n sub_tokens.append(cur_substr)\\n start = end\\n\\n if is_bad:\\n output_tokens.append(self.unk_token)\\n else:\\n output_tokens.extend(sub_tokens)\\n return output_tokens\",\n \"def _multiprocess_tokenize(self, num_workers: int):\\n\\n # While displaying progress bar through tqdm, specify total number of\\n # sequences to tokenize, because tqdm won't know in case of pool.imap\\n with mp.Pool(num_workers) as pool:\\n print(f\\\"[{self._split}] Tokenizing questions...\\\")\\n _question_tuples = self.questions.items()\\n _question_indices = [t[0] for t in _question_tuples]\\n _questions = list(\\n tqdm(\\n pool.imap(word_tokenize, [t[1] for t in _question_tuples]),\\n total=len(self.questions)\\n )\\n )\\n self.questions = {\\n i: question + [\\\"?\\\"] for i, question in\\n zip(_question_indices, _questions)\\n }\\n # Delete variables to free memory.\\n del _question_tuples, _question_indices, _questions\\n\\n print(f\\\"[{self._split}] Tokenizing answers...\\\")\\n _answer_tuples = self.answers.items()\\n _answer_indices = [t[0] for t in _answer_tuples]\\n _answers = list(\\n tqdm(\\n pool.imap(word_tokenize, [t[1] for t in _answer_tuples]),\\n total=len(self.answers)\\n )\\n )\\n self.answers = {\\n i: answer + [\\\"?\\\"] for i, answer in\\n zip(_answer_indices, _answers)\\n }\\n # Delete variables to free memory.\\n del _answer_tuples, _answer_indices, _answers\\n\\n print(f\\\"[{self._split}] Tokenizing captions...\\\")\\n # Convert dict to separate lists of image_ids and captions.\\n _caption_tuples = self.captions.items()\\n _image_ids = [t[0] for t in _caption_tuples]\\n _captions = list(\\n tqdm(\\n pool.imap(word_tokenize, [t[1] for t in _caption_tuples]),\\n total=(len(_caption_tuples))\\n )\\n )\\n # Convert tokenized captions back to a dict.\\n self.captions = {i: c for i, c in zip(_image_ids, _captions)}\",\n \"def tokenize_text(self, s):\\n tokens = []\\n # We could just have a \\\"while s:\\\" here instead of \\\"for line: while\\n # line:\\\", but for really large log messages with heavy\\n # tokenization, the cost in both performance and memory\\n # consumption of the approach taken was atrocious.\\n for line in s.replace(\\\"\\\\r\\\\n\\\", \\\"\\\\n\\\").split(\\\"\\\\n\\\"):\\n line = line + \\\"\\\\n\\\"\\n while line:\\n best_match = best_conv = best_userdata = None\\n for test in self._formatters:\\n match = test[0].search(line)\\n # If we find and match and (a) its our first one, or (b) it\\n # matches text earlier than our previous best match, or (c) it\\n # matches text at the same location as our previous best match\\n # but extends to cover more text than that match, then this is\\n # our new best match.\\n #\\n # Implied here is that when multiple formatters match exactly\\n # the same text, the first formatter in the registration list wins.\\n if match and (\\n (best_match is None)\\n or (match.start() < best_match.start())\\n or (\\n (match.start() == best_match.start())\\n and (match.end() > best_match.end())\\n )\\n ):\\n best_match = match\\n best_conv = test[1]\\n best_userdata = test[2]\\n # If we found a match...\\n if best_match:\\n # ... add any non-matching stuff first, then the matching bit.\\n start = best_match.start()\\n end = best_match.end()\\n if start > 0:\\n tokens.append(\\n _item(match=line[:start], converter=self.format_text, userdata=None)\\n )\\n tokens.append(\\n _item(match=best_match, converter=best_conv, userdata=best_userdata)\\n )\\n line = line[end:]\\n else:\\n # Otherwise, just add the rest of the string.\\n tokens.append(_item(match=line, converter=self.format_text, userdata=None))\\n line = \\\"\\\"\\n return ViewVCHtmlFormatterTokens(tokens)\",\n \"def tokenize(self, input: str) -> List[Tuple[str, int, int]]:\\n raise NotImplementedError\",\n \"def _multiprocess_tokenize(self, num_workers: int):\\n\\n # While displaying progress bar through tqdm, specify total number of\\n # sequences to tokenize, because tqdm won't know in case of pool.imap\\n with mp.Pool(num_workers) as pool:\\n print(f\\\"[{self._split}] Tokenizing questions...\\\")\\n _question_tuples = self.questions.items()\\n _question_indices = [t[0] for t in _question_tuples]\\n _questions = list(\\n tqdm(\\n pool.imap(word_tokenize, [t[1] for t in _question_tuples]),\\n total=len(self.questions),\\n )\\n )\\n self.questions = {\\n i: question + [\\\"?\\\"]\\n for i, question in zip(_question_indices, _questions)\\n }\\n # Delete variables to free memory.\\n del _question_tuples, _question_indices, _questions\\n\\n print(f\\\"[{self._split}] Tokenizing answers...\\\")\\n _answer_tuples = self.answers.items()\\n _answer_indices = [t[0] for t in _answer_tuples]\\n _answers = list(\\n tqdm(\\n pool.imap(word_tokenize, [t[1] for t in _answer_tuples]),\\n total=len(self.answers),\\n )\\n )\\n self.answers = {\\n i: answer + [\\\"?\\\"] for i, answer in zip(_answer_indices, _answers)\\n }\\n # Delete variables to free memory.\\n del _answer_tuples, _answer_indices, _answers\\n\\n print(f\\\"[{self._split}] Tokenizing captions...\\\")\\n # Convert dict to separate lists of image_ids and captions.\\n _caption_tuples = self.captions.items()\\n _image_ids = [t[0] for t in _caption_tuples]\\n _captions = list(\\n tqdm(\\n pool.imap(word_tokenize, [t[1] for t in _caption_tuples]),\\n total=(len(_caption_tuples)),\\n )\\n )\\n # Convert tokenized captions back to a dict.\\n self.captions = {i: c for i, c in zip(_image_ids, _captions)}\",\n \"def tokenize_tag(text):\\n return [tok for tok in single_tokenizer(text)]\",\n \"def tokenize(self, path):\\n assert os.path.exists(path)\\n # Add words to the dictionary\\n with open(path, 'r') as f:\\n tokens = 0\\n for line in f:\\n words = line.split() + ['<eos>']\\n tokens += len(words)\\n for word in words:\\n self.dictionary.add_word(word)\\n\\n # Tokenize file content\\n with open(path, 'r') as f:\\n ids = []\\n token = 0\\n for line in f:\\n words = line.split() + ['<eos>']\\n for word in words:\\n ids.append(self.dictionary.word2idx[word])\\n token += 1\\n\\n return ids\",\n \"def tokenize_chars(line):\\n return\",\n \"def wordize(lines):\\n parser = Parser()\\n tokenizer = Tokenizer()\\n word_ctr = WordCounter()\\n words = []\\n for l in lines :\\n if (l.rstrip()) :\\n statement = parser.parseSentence(l, int(word_ctr))\\n token_lists = tokenizer.tokenizeStatement(statement, int(word_ctr))\\n for l in token_lists :\\n if len(l) > 0 :\\n words.append(l)\\n word_ctr += 1\\n return words\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n clean_tokens = []\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n return clean_tokens\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for token in tokens:\\n clean_token = lemmatizer.lemmatize(token).lower().strip()\\n clean_tokens.append(clean_token)\\n\\n return clean_tokens\",\n \"def _tokenize(self, string):\\n self._tokens = []\\n\\n # Split and strip the input string by newlines\\n for token in re.split('(.*)', string):\\n if token.strip() != '':\\n self._tokens.append(token)\",\n \"def _whitespace_tokenize_with_offsets(self, input_tensor):\\n (values, row_splits, start_offsets, end_offsets) = (\\n gen_whitespace_tokenizer_v2.tf_text_whitespace_tokenize_with_offsets_v2(\\n input_values=input_tensor, input_config=self._config))\\n values = RaggedTensor.from_nested_row_splits(\\n flat_values=values,\\n nested_row_splits=[row_splits])\\n start_offsets = RaggedTensor.from_nested_row_splits(\\n flat_values=start_offsets,\\n nested_row_splits=[row_splits])\\n end_offsets = RaggedTensor.from_nested_row_splits(\\n flat_values=end_offsets,\\n nested_row_splits=[row_splits])\\n return (values, start_offsets, end_offsets)\",\n \"def tokenize(self, path):\\n assert os.path.exists(path)\\n # Add words to the dictionary\\n with open(path, 'r', encoding=\\\"utf8\\\") as f:\\n for line in f:\\n words = line.split() + ['<eos>']\\n for word in words:\\n self.dictionary.add_word(word)\\n\\n # Tokenize file content\\n with open(path, 'r', encoding=\\\"utf8\\\") as f:\\n idss = []\\n for line in f:\\n words = line.split() + ['<eos>']\\n ids = []\\n for word in words:\\n ids.append(self.dictionary.word2idx[word])\\n idss.append(torch.tensor(ids).type(torch.int64))\\n ids = torch.cat(idss)\\n\\n return ids\",\n \"def span_tokenize_words(self, text):\\n\\t\\tsentences = self.tokenize_sentences(text)\\n\\t\\ttokens_per_sentence = list()\\n\\t\\tsentence_offset = 0\\n\\t\\t\\n\\t\\tsentence_counter = 0\\n\\t\\tfor sentence in sentences:\\n\\t\\t\\tsentence_tokens = list()\\n\\t\\t\\tfor token in self.word_tokenizer.span_tokenize(sentence):\\n\\t\\t\\t\\t# save actual token together with it's positions\\n\\t\\t\\t\\tbegin = token[0] + sentence_offset\\n\\t\\t\\t\\tend = token[1] + sentence_offset\\n\\t\\t\\t\\ttoken_tuple = (text[begin:end],begin,end,sentence_counter)\\n\\t\\t\\t\\tsentence_tokens.append(token_tuple)\\n\\t\\t\\t\\t\\n\\t\\t\\ttokens_per_sentence.append(sentence_tokens)\\n\\t\\t\\t\\n\\t\\t\\tsentence_counter = sentence_counter + 1\\n\\t\\t\\tsentence_offset = sentence_offset + len(sentence) + 1\\n\\t\\t\\n\\t\\treturn tokens_per_sentence\",\n \"def tokenize(self, input_string: str) -> List[str]:\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n\\n return clean_tokens\",\n \"def split_whitespace_tokens(line):\\n in_quote = False\\n token = \\\"\\\"\\n token_start = 0\\n for i, char in enumerate(line):\\n if char == ' ':\\n if len(token) > 0:\\n yield (token_start, token)\\n token = \\\"\\\"\\n else:\\n if len(token) == 0:\\n token_start = i\\n token += char\\n if len(token) > 0:\\n yield (token_start, token)\",\n \"def tokenize(self, path, training_set=False):\\n assert os.path.exists(path)\\n with open(path, encoding='utf8') as fin:\\n num_lines = sum(1 for _ in fin.readlines())\\n with open(path, 'r', encoding=\\\"utf8\\\") as f:\\n words = []\\n for i, line in enumerate(tqdm(f, total=num_lines)):\\n if self.max_lines > 0 and i > self.max_lines:\\n break\\n line = line.strip()\\n if not line:\\n continue # Skip empty lines.\\n elif line.startswith('='):\\n continue # Skip headers.\\n else:\\n sentence = (self.order - 1) * [SOS] + \\\\\\n [process(word, self.lower) for word in line.split()] + [EOS]\\n if training_set:\\n words.extend(sentence)\\n self.vocab.update(sentence)\\n else:\\n sentence = [word if word in self.vocab else UNK for word in sentence]\\n words.extend(sentence)\\n return words\",\n \"def tokenize(self, path):\\n assert os.path.exists(path)\\n # Add symbol to the dictionary\\n with open(path, 'r') as f:\\n tokens = 0\\n for line in f:\\n tokens += len(line)\\n for s in line:\\n self.dictionary.add_symbol(s)\\n\\n # Tokenize file content\\n with open(path, 'r') as f:\\n ids = torch.LongTensor(tokens)\\n token = 0\\n for line in f:\\n for s in line:\\n ids[token] = self.dictionary.symbol2idx[s]\\n token += 1\\n\\n return ids\",\n \"def tokenize(self, path):\\n assert os.path.exists(path)\\n # Add words to the dictionary\\n with open(path, 'r') as f:\\n tokens = 0\\n for line in f:\\n words = line.split() + ['<eos>']\\n tokens += len(words)\\n for word in words:\\n self.dictionary.add_word(word)\\n\\n # Tokenize file content\\n with open(path, 'r') as f:\\n ids = torch.LongTensor(tokens)\\n token = 0\\n for line in f:\\n words = line.split() + ['<eos>']\\n for word in words:\\n ids[token] = self.dictionary.word2idx[word]\\n token += 1\\n\\n return ids\",\n \"def tokenize(self, path):\\n assert os.path.exists(path)\\n # Add words to the dictionary\\n with open(path, 'r') as f:\\n tokens = 0\\n for line in f:\\n words = line.split() + ['<eos>']\\n tokens += len(words)\\n for word in words:\\n self.dictionary.add_word(word)\\n\\n # Tokenize file content\\n with open(path, 'r') as f:\\n ids = torch.LongTensor(tokens)\\n token = 0\\n for line in f:\\n words = line.split() + ['<eos>']\\n for word in words:\\n ids[token] = self.dictionary.word2idx[word]\\n token += 1\\n\\n return ids\",\n \"def preprocess(self, sentence, vocab_set=None):\\n tokens = sentence.split()\\n new_tokens = []\\n for token in tokens:\\n new_tokens += self.__clean(token)\\n tokens = new_tokens\\n\\n tokens = self.__normalize_document(' '.join(tokens))\\n\\n return tokens\",\n \"def tokenize(text):\\n\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n return [lemmatizer.lemmatize(token).lower().strip() for token in tokens]\",\n \"def preprocess(self,text):\\n return preprocess.get_tokens(text)\",\n \"def prepare_data(self, lines: List[str]) -> List[str]:\\n if self.is_tokenized:\\n if self.parser == \\\"spacy\\\":\\n lines = [l.split() for l in lines]\\n elif self.parser == \\\"udpipe\\\":\\n lines = [[l.split()] for l in lines]\\n\\n return lines\",\n \"def tokenize(self):\\n count = 0\\n for entry in self._entries:\\n token_pairs = []\\n for relation in entry['relations']:\\n assert len(relation) == 3\\n token_pairs.append((relation[0][0],relation[1][0],relation[2][0]))\\n\\n num_rels = len(entry['relations'])\\n num_random_rels = (self._max_seq_length - 2) // 3 - num_rels\\n\\n if num_random_rels>0:\\n pass\\n # gt_pairs = {(rel[0],rel[2]) for rel in entry['relations']}\\n # random_pairs = self._get_random_pair(entry['objects'], gt_pairs, num_random_rels)\\n # for pair in list(random_pairs):\\n # token_pairs.append((pair[0][0],'background', pair[1][0]))\\n else:\\n for i in range(-num_random_rels):\\n token_pairs.pop()\\n\\n random.shuffle(token_pairs)\\n tokens = []\\n for pair in token_pairs:\\n tokens.extend(pair)\\n\\n tokens = ['[CLS]'] + tokens + ['[SEP]']\\n tokens_char = tokens\\n\\n target = [self._tokenizer.vocab.get(self._tokenizer.tokenize(x)[0], self._tokenizer.vocab['[UNK]']) if i%3==2 else -1 for i, x in enumerate(tokens)]\\n tokens = [self._tokenizer.vocab.get(self._tokenizer.tokenize(x)[0], self._tokenizer.vocab['[UNK]']) if i%3!=2 else self._tokenizer.vocab.get('[MASK]', self._tokenizer.vocab['[UNK]']) for i, x in enumerate(tokens)]\\n \\n for i in range(len(tokens)):\\n if target[i] != -1:\\n print(tokens_char[i],tokens[i],target[i])\\n\\n segment_ids = [0] * len(tokens)\\n input_mask = [1] * len(tokens)\\n # input_mask = [1 if i%3==2 else 0 for i in range(len(tokens))]\\n # co_attention_mask = [-1 if i%3==2 else 1 for i in range(len(tokens))]\\n # co_attention_mask = torch.zeros((self._max_region_num, self._max_seq_length))\\n # co_attention_mask[0] = -1\\n # co_attention_mask[-1] = -1\\n \\n if len(tokens) < self._max_seq_length:\\n padding = [self._padding_index] * (self._max_seq_length - len(tokens))\\n tokens = tokens + padding\\n input_mask += padding\\n segment_ids += padding \\n target += [-1] * len(padding) \\n\\n assert_eq(len(tokens), self._max_seq_length)\\n entry['input_ids'] = tokens \\n entry[\\\"input_mask\\\"] = input_mask\\n entry['segment_ids'] = segment_ids\\n # entry[\\\"co_attention_mask\\\"] = co_attention_mask\\n entry['target'] = target\\n\\n sys.stdout.write('%d/%d\\\\r' % (count, len(self._entries)))\\n sys.stdout.flush()\\n count += 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69884706","0.66323274","0.6459621","0.64471626","0.6395952","0.6366297","0.63627106","0.6332375","0.62884957","0.62397844","0.620047","0.61909837","0.6182466","0.61787194","0.6176044","0.61732286","0.6165838","0.6162342","0.6160397","0.6157418","0.615142","0.6129513","0.6124969","0.61070395","0.6058943","0.6048806","0.6046805","0.6020645","0.6020171","0.5999851","0.59908134","0.59895146","0.59850377","0.59798986","0.59663945","0.5961288","0.59568745","0.5953661","0.5939347","0.59392077","0.5907301","0.58812547","0.5873932","0.58699256","0.58578634","0.58509135","0.5849148","0.5841671","0.58408695","0.58387196","0.582752","0.58274585","0.58252877","0.5822991","0.58172214","0.58162224","0.581546","0.58142805","0.5788797","0.5784557","0.57842773","0.57840234","0.5781467","0.577383","0.5773533","0.57676417","0.5767148","0.57589984","0.5751371","0.5748216","0.5739918","0.5732561","0.57267535","0.5721466","0.5717346","0.5716998","0.57153744","0.57062733","0.5703294","0.57018965","0.5698772","0.5698591","0.5684695","0.56829935","0.5676587","0.5671458","0.56628734","0.56603163","0.5659083","0.5658848","0.5655517","0.5653851","0.5634147","0.56172305","0.5617033","0.5617033","0.5615655","0.56137455","0.5611802","0.56096035","0.55984676"],"string":"[\n \"0.69884706\",\n \"0.66323274\",\n \"0.6459621\",\n \"0.64471626\",\n \"0.6395952\",\n \"0.6366297\",\n \"0.63627106\",\n \"0.6332375\",\n \"0.62884957\",\n \"0.62397844\",\n \"0.620047\",\n \"0.61909837\",\n \"0.6182466\",\n \"0.61787194\",\n \"0.6176044\",\n \"0.61732286\",\n \"0.6165838\",\n \"0.6162342\",\n \"0.6160397\",\n \"0.6157418\",\n \"0.615142\",\n \"0.6129513\",\n \"0.6124969\",\n \"0.61070395\",\n \"0.6058943\",\n \"0.6048806\",\n \"0.6046805\",\n \"0.6020645\",\n \"0.6020171\",\n \"0.5999851\",\n \"0.59908134\",\n \"0.59895146\",\n \"0.59850377\",\n \"0.59798986\",\n \"0.59663945\",\n \"0.5961288\",\n \"0.59568745\",\n \"0.5953661\",\n \"0.5939347\",\n \"0.59392077\",\n \"0.5907301\",\n \"0.58812547\",\n \"0.5873932\",\n \"0.58699256\",\n \"0.58578634\",\n \"0.58509135\",\n \"0.5849148\",\n \"0.5841671\",\n \"0.58408695\",\n \"0.58387196\",\n \"0.582752\",\n \"0.58274585\",\n \"0.58252877\",\n \"0.5822991\",\n \"0.58172214\",\n \"0.58162224\",\n \"0.581546\",\n \"0.58142805\",\n \"0.5788797\",\n \"0.5784557\",\n \"0.57842773\",\n \"0.57840234\",\n \"0.5781467\",\n \"0.577383\",\n \"0.5773533\",\n \"0.57676417\",\n \"0.5767148\",\n \"0.57589984\",\n \"0.5751371\",\n \"0.5748216\",\n \"0.5739918\",\n \"0.5732561\",\n \"0.57267535\",\n \"0.5721466\",\n \"0.5717346\",\n \"0.5716998\",\n \"0.57153744\",\n \"0.57062733\",\n \"0.5703294\",\n \"0.57018965\",\n \"0.5698772\",\n \"0.5698591\",\n \"0.5684695\",\n \"0.56829935\",\n \"0.5676587\",\n \"0.5671458\",\n \"0.56628734\",\n \"0.56603163\",\n \"0.5659083\",\n \"0.5658848\",\n \"0.5655517\",\n \"0.5653851\",\n \"0.5634147\",\n \"0.56172305\",\n \"0.5617033\",\n \"0.5617033\",\n \"0.5615655\",\n \"0.56137455\",\n \"0.5611802\",\n \"0.56096035\",\n \"0.55984676\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3183,"cells":{"query":{"kind":"string","value":"tokenize using the nltk default (ptb + a 'punkt' sentence tokenizer)"},"document":{"kind":"string","value":"def tokenize(self, N=None, drop_punctuation=True, lower=True):\n for tok in self.tokenize_generic(word_tokenize, N=N, drop_punctuation=drop_punctuation):\n if lower:\n tok = tok.lower()\n yield tok"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def gpt2_tokenize(self, text: str):\n return self.bpe_tokenize(text)","def preprocess(text):\n\tX = []\n\tsent_detector = nltk.data.load('tokenizers/punkt/english.pickle')\n\tfor t in text:\n\t\tsents = sent_detector.tokenize(t)\n\t\tresult = ''\n\t\tfor s in sents:\n\t\t\ttokens = word_tokenize(s)\n\t\t\tresult += ' ' + ' '.join(tokens)\n\t\tX.append(result)\n\treturn X","def sentence_tokenizer(text):\n return sent_tokenize(text)","def tokenize(sentence):\n return nltk.word_tokenize(sentence)","def preprocess_sent(sent):\n #tokenized = word_tokenize(sent.lower())\n tokenizer = Tok()\n tokenized = tokenizer.tokenize(sent.lower())\n return tokenized","def train_punkt_sent_tokenizer(train_ref,train_pickle):\r\n\timport nltk.tokenize.punkt\r\n\ttokenizer = nltk.tokenize.punkt.PunktSentenceTokenizer()\r\n\t\r\n\t# read training corpus\r\n\timport codecs\r\n\ttext = codecs.open(train_ref).read()\r\n\ttokenizer.train(text)\r\n\r\n\t# dump pickled tokenizer\r\n\timport pickle\r\n\tout = open(train_pickle,\"wb\")\r\n\tpickle.dump(tokenizer, out)\r\n\tout.close()","def tokenize(text):\n lowers = text.lower()\n trans = {ord(c): None for c in string.punctuation}\n no_punctuation = lowers.translate(trans)\n trans_dig = {ord(c): None for c in string.digits}\n no_digits = no_punctuation.translate(trans_dig)\n tokens = nltk.word_tokenize(no_digits)\n return tokens","def tokenize_text(text):\n return nltk.tokenize.word_tokenize(text)","def tokenize(raw_text):\n tokenized_text = nltk.tokenize.word_tokenize(raw_text)\n return tokenized_text","def tokenize(text):\n text = text.decode('utf-8')\n return nltk.word_tokenize(text)","def tokenize_pt(text):\n #primeiros padrões, separação de palavra de [. , ? ! ( ) [ ] : ; ' ' \" \" ]\n return split_level_two(split_level_one(text))","def tokenize(self, start_pos=0, text=None):\n pass","def tokenize(sentence):\n tokens = nltk.word_tokenize(sentence)\n return tokens","def tokenize(text):\n sentence = Sentence(text)\n return sentence.tokens()","def get_tokens(sent):\n return word_tokenize(sent)","def tokenize (self, text):\n if self.type == \"gpt2\":\n return self._tokenizer.tokenize(text)\n if self.type == \"bpe\":\n return self._tokenizer.EncodeAsPieces(text)","def _tokenize(self, text: str) -> List[str]:\n return self.bert_model.tokenize(text.strip())","def _tokenize(self, text: str) -> List[str]:\n return self.bpe.tokenize(text)","def _tokenize(text, language_code):\n seq = annotool.raw2basicseq(text, language_code, pos=False)\n word_seq = seq['word']\n return word_seq","def tokenize(txt):\n Depunc = depunctuate(txt).lower()\n Tokens = word_tokenize(Depunc)\n \n return Tokens","def wordpunct_space_tokenize(sent):\n return _rts.tokenize(sent)","def tokenize(text):\n #Clean data, remove all character except character and number,such as punctuation etc.\n text = re.sub(r'[^a-zA-Z0-9]', ' ', text.lower())\n tokens = word_tokenize(text)\n tokens = [WordNetLemmatizer().lemmatize(word) for word in tokens if word not in ST_english]\n return tokens","def simple_tokenizer(text):\n re_tok = re.compile(punctuation_string)\n return re_tok.sub(' ', text).split()","def english_tokenzier(text: str):\n TOKENIZER = ToktokTokenizer().tokenize\n return TOKENIZER(text)","def naive(self, text):\n\t\t#print(text)\n\t\ttokenizedText = []\n\t\tfor k in text: #look at each entity in one sentence\n\t\t\t\n\t\t\ta = \"\"#stores the current word \n\t\t\trun = []; #appends all words in a particular sentence\n\t\t\tfor i in range(len(k)):\n\t\t\t\t\n\t\t\t\tif(k[i] == ' ' or k[i] == '\t'): #tokenization at space or tab\n\t\t\t\t\t\n\t\t\t\t\tif(a!=\"\"):\n\t\t\t\t\t\tif(a[-1] == ',' or a[-1] == '-' or a[-1] == \"\\'\" or a[-1] == \";\" or a[-1] == \":\" or a[-1] ==\"!\" or a[-1] == \"?\" or a[-1] ==\"\\\"\") : #but remove mentioned punctuations from the end of the word, if present\n\t\t\t\t\t\t\ta = a[:-1]\n\t\t\t\t\t\tif(len(a)>0 and a[0] == \"\\\"\"):#remove starting quotes\n\t\t\t\t\t\t\ta = a[1:]\n\t\t\t\t\t\tif(len(a)>0):\n\t\t\t\t\t\t\trun.append(a)\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\ta = \"\"\n\n\n\t\t\t\telif(i == len(k)-1): #remove the last punctuation mark, if present\n\t\t\t\t\t\n\t\t\t\t\ta = a+k[i];\n\t\t\t\t\t\n\t\t\t\t\tif(a[-1] == '.' or a[-1] == '\\\"' or a[-1] ==\"!\" or a[-1] == \"?\" or a[-1] ==\"\\'\" ):\n\t\t\t\t\t\ta = a[:-1]\n\t\t\t\t\tif(len(a)>0 and a[0] == \"\\\"\"):\n\t\t\t\t\t\ta = a[1:]\n\t\t\t\t\tif(len(a)>0):\n\t\t\t\t\t\trun.append(a)\n\t\t\t\t\t\t\n\t\t\t\t\t\ta = \"\"\n\n\n\t\t\t\telse:\n\t\t\t\t\t\n\t\t\t\t\tif((k[i] == ',' or k[i] == ':' or k[i] == ';') and k[i+1]!= ' ' ): # for other punctuation marks followed by a space\n\t\t\t\t\t\t#print(k[i-1])\n\t\t\t\t\t\tif(len(a)>0):\n\t\t\t\t\t\t\tif(a[-1] == '\\\"' or a[-1] ==\"!\" or a[-1] == \"?\" ):\n\t\t\t\t\t\t\t\ta = a[:-1]\n\t\t\t\t\t\t\tif(len(a)>0 and a[0] == \"\\\"\"):\n\t\t\t\t\t\t\t\ta = a[1:]\n\t\t\t\t\t\t\tif(len(a)>0):\n\t\t\t\t\t\t\t\trun.append(a)\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\ta = \"\"\n\n\n\t\t\t\t\telse:\n\n\t\t\t\t\t\ta = a+k[i];\n\n\t\t\ttokenizedText.append(run)\t\t\n\n\t\t\n\t\t\t\n\n\n\n\n\t\t#Fill in code here\n\n\t\treturn tokenizedText","def _tokenize(self, text: str) -> List[str]:\n text = text.lower().strip()\n return self.bpe.tokenize(text)","def tokenize(text):\n wt = nltk.RegexpTokenizer(pattern=r'\\s+', gaps=True)\n tokens = wt.tokenize(text)\n return tokens","def tokenize_text(document, nlp):\n\n return [token.text for token in nlp(document)]","def custom_tokenizer(nlp, infix_reg):\n return Tokenizer(nlp.vocab, infix_finditer=infix_reg.finditer)","def tokenize(self, text, **kwargs):\n if self.opt['tracker'] == 'babi6':\n text = babi6_dirty_fix(text)\n text = text.replace('<SILENCE>', '_SILENCE_')\n\n return [t.text for t in NLP.tokenizer(text)]","def tokenize(text):\n tokens=word_tokenize(text)\n lemmatizer=WordNetLemmatizer()\n \n clean_tokens=[]\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n return clean_tokens\n pass","def tokenize(text):\n text = text.lower()\n remove = re.compile('[' + string.punctuation + '0-9\\\\r\\\\t\\\\n]')\n cleanText = re.sub(remove, \" \", text)\n tokens = nltk.word_tokenize(cleanText)\n tokens = [w.lower() for w in tokens if (len(w) >= 3 and w not in ENGLISH_STOP_WORDS)]\n return tokens","def tokenize(review):\n\n token = strip_multiple_whitespaces(strip_punctuation(review))\n return [token.split() for token in simple_preprocess(token) if token not in STOPWORDS]","def tokenize(text):\n tokens = TreebankWordTokenizer().tokenize(text)\n tokens = lemmatize(tokens)\n tokens = filter(lambda s: len(s) > 2, tokens) # remove tokens with < 3 chars\n return tokens","def tokenize(text):\n return text.split(' ')","def tokenize_and_stem(doc):\n punctuation_remover = dict((ord(char), None) for char in string.punctuation)\n tokens = nltk.word_tokenize(doc.lower().translate(punctuation_remover))\n return PlagiarismDetector.stem_tokens(tokens)","def tokenize(text):\n \n #regular expression to avoid pucntuations or any special character\n tokenizer = nltk.RegexpTokenizer(r\"\\w+\")\n \n #tokenizing text\n tokens = tokenizer.tokenize(text)\n \n #initiating lemmatizer\n lemmatizer = WordNetLemmatizer()\n \n #iteratating through each token\n clean_tokens = []\n for tok in tokens:\n \n #stop words are irrelevant in this context of classifying response\n if (tok.lower() not in stopwords.words(\"english\")):\n \n # lemmatizing, normalizing case, and removing leading/trailing white space\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n \n return clean_tokens","def tokenize(text):\n \n #regular expression to avoid pucntuations or any special character\n tokenizer = nltk.RegexpTokenizer(r\"\\w+\")\n \n #tokenizing text\n tokens = tokenizer.tokenize(text)\n \n #initiating lemmatizer\n lemmatizer = WordNetLemmatizer()\n \n #iteratating through each token\n clean_tokens = []\n for tok in tokens:\n \n #stop words are irrelevant in this context of classifying response\n if (tok.lower() not in stopwords.words(\"english\")):\n \n # lemmatizing, normalizing case, and removing leading/trailing white space\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n \n return clean_tokens","def tokenizer(self):\n tokenizer = RegexpTokenizer(r'\\w+')\n \n self.tweet_tokenized_train = [tokenizer.tokenize(x.lower()) for x in self.tweet_prepro_train]\n self.tweet_tokenized_test = [tokenizer.tokenize(x.lower()) for x in self.tweet_prepro_test]","def tokenizer(s):\n\n tokens = tokenize(s.lower()) # apply the nltk tokenizer\n tokens = [t for t in tokens if doc_frequency[t]>5 and t not in stop_words]# and doc_frequency[t]<3000]\n \n return tokens","def tokenize(self, text):\n\n text = convert_to_unicode(text)\n\n output_tokens = []\n for token in whitespace_tokenize(text):\n chars = list(token)\n if len(chars) > self.max_input_chars_per_word:\n output_tokens.append(self.unk_token)\n continue\n\n is_bad = False\n start = 0\n sub_tokens = []\n while start < len(chars):\n end = len(chars)\n cur_substr = None\n while start < end:\n substr = \"\".join(chars[start:end])\n ### joonho.lim @ 2019-03-15\n # if start > 0:\n # substr = \"##\" + substr\n # print ( '[substr]\\t%s\\t%s\\t%d\\t%d' % ( substr, substr in self.vocab, start, end))\n if substr in self.vocab:\n cur_substr = substr\n break\n end -= 1\n if cur_substr is None:\n is_bad = True\n break\n sub_tokens.append(cur_substr)\n start = end\n\n if is_bad:\n output_tokens.append(self.unk_token)\n else:\n output_tokens.extend(sub_tokens)\n output_tokens.insert(0, '[CLS]')\n output_tokens.append('[SEP]')\n return output_tokens","def tokenize(text: str):\n # Create list of word tokens\n token_list = []\n # nlp = init_nlp(TaggingMethod.SPACY, Lang.ES, size=DictionarySize.MEDIUM)\n doc = nlp(text)\n token_list = [token.text for token in doc]\n # for token in doc:\n # token_list.append(token.text)\n return token_list","def pre_process(text):\n # replace (,.'\") with ''\n text = text.replace(',', '')\n text = text.replace('.', '')\n text = text.replace(\"'\", '')\n text = text.replace(\"\\\"\", '')\n\n # tokenize into words\n tokens = [word for sent in sent_tokenize(text) for word in word_tokenize(sent)]\n\n # remove stopwords\n stop = stopwords.words('english')\n tokens = [token for token in tokens if token not in stop]\n\n # remove words less than three letters\n tokens = [word for word in tokens if len(word) >= 3]\n\n # lower capitalization\n tokens = [word.lower() for word in tokens]\n\n # lemmatize\n lmtzr = WordNetLemmatizer()\n tokens = [lmtzr.lemmatize(word) for word in tokens]\n\n return tokens","def detokenize(tokens):\n pass","def basic_tokenize(tweet):\n tweet = \" \".join(re.split(\"[^a-zA-Z.,!?]*\", tweet.lower())).strip()\n return tweet.split()","def process_token_sentence(text):\n\n sentences = nltk.sent_tokenize(text)\n tokenized_sentences = [nltk.word_tokenize(sentence) for sentence in sentences]\n tagged_sentences = [nltk.pos_tag(sentence) for sentence in tokenized_sentences]\n sentences = nltk.ne_chunk_sents(tagged_sentences, binary=True)\n\n return sentences","def tokenize(t):\n tweet_tok = TweetTokenizer(strip_handles=True, reduce_len=True)\n tokens = tweet_tok.tokenize(t)\n wnl = WordNetLemmatizer()\n stems = []\n for item in tokens:\n stems.append(wnl.lemmatize(item))\n return stems","def tokenize(src):\n\n pass","def _word_tokenize_spacy(sent):\n tokens = SQuADDataTokenizer._spacy_tokenizer(sent)\n return tokens","def tokenize(sentence):\n lower_s = sentence.lower()\n no_punc_s = lower_s.translate(TRANS, string.punctuation)\n\n word_list = no_punc_s.split()\n\n return word_list","def english_tokenize(text):\n tokens = word_tokenize(text, 'english')\n stems = stem_tokens(tokens, stemmers['english'])\n stems = [i for i in stems if i not in punctuations]\n return stems","def _tokenize(self, text):\n bpe_tokens = []\n for token in re.findall(self.pat, text):\n bpe_tokens.extend([t for t in self.bpe(token).split(\" \")])\n return bpe_tokens","def tokenize(text):\n global TOK\n tokens = TOK.tokenize(text)\n output = {\n 'words': tokens.words(),\n 'offsets': tokens.offsets(),\n 'pos': tokens.pos(),\n 'lemma': tokens.lemmas(),\n 'ner': tokens.entities(),\n }\n return output","def tokenize(text):\n\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n return [lemmatizer.lemmatize(token).lower().strip() for token in tokens]","def tokenize(text):\n \n text.lower() # convert to lowercase\n text = re.sub(r\"[^a-zA-Z0-9]\", \" \", text) #remove punctuation\n words = word_tokenize(text) # tokenize by individual word\n words = [w for w in words if w not in stopwords.words(\"english\")] #remove stop words\n lemmed = [WordNetLemmatizer().lemmatize(w) for w in words] #lemminization\n \n return words","def sentence_tokenize(tokenizer, sent):\n tokens = tokenizer.EncodeAsIds(sent).tokenization\n return tokens","def tokenize(doc):\n\n # Calls NLTK function to tokenize the document. Broken into individual words, cleans out punctuation\n tokens = nltk.word_tokenize(doc)\n\n return tokens","def tokenize(self, text):\n # text = convert_to_unicode(text)\n\n output_tokens = []\n for token in split_by_whitespace(text):\n chars = list(token)\n if len(chars) > self.max_input_chars_per_word:\n output_tokens.append(self.unk_token)\n continue\n\n is_bad = False\n start = 0\n sub_tokens = []\n while start < len(chars):\n end = len(chars)\n cur_substr = None\n while start < end:\n substr = \"\".join(chars[start:end])\n if start > 0:\n substr = \"##\" + substr\n if substr in self.vocab:\n cur_substr = substr\n break\n end -= 1\n if cur_substr is None:\n is_bad = True\n break\n sub_tokens.append(cur_substr)\n start = end\n\n if is_bad:\n output_tokens.append(self.unk_token)\n else:\n output_tokens.extend(sub_tokens)\n return output_tokens","def ie_preprocess(document):\n sentences = nltk.sent_tokenize(document) #NLTK default sentence segmenter\n #print sentences # sentences are segmented\n sentences = [nltk.word_tokenize(sent) for sent in sentences] # NLTK word tokenizer \n #print sentences # sentences are tokenized\n sentences = [nltk.pos_tag(sent) for sent in sentences] # NLTK POS tagger \n #print sentences # sentences are POS tagged\n return sentences","def preprocess_document(raw,sentence_level):\r\n\r\n\t# raw = raw.decode(\"utf-8\")\r\n\t# raw = raw.encode(\"ascii\",\"ignore\")\r\n\t\r\n\tfrom nltk.tokenize.punkt import PunktSentenceTokenizer, PunktParameters\r\n\tparam = PunktParameters()\r\n\ttokenizer = PunktSentenceTokenizer(param)\r\n\tif sentence_level:\r\n\t\tsentences = tokenizer.tokenize(raw)\r\n\t\tsentences_words = list()\r\n\t\tfor s in sentences:\r\n\t\t\tsentences_words.append((s.strip(),preprocess_sentence(s)))\r\n\t\treturn sentences_words\r\n\telse:\r\n\t\treturn [(raw.strip(),preprocess_sentence(raw))]","def word_tokenize(text):\n word_list = []\n for sentences in nltk.sent_tokenize(text):\n for words in nltk.word_tokenize(sentences):\n word_list.append(words)\n return word_list","def identity_tokenizer(text):\n return text","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n clean_tokens = []\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n return clean_tokens","def tokenization(text):\n\n global tokenizer_tree\n tokenised_document = tokenizer_tree.tokenize(text)\n return tokenised_document","def tokenize(tweet):\n tweet = \" \".join(re.split(\"[^a-zA-Z]*\", tweet.lower())).strip()\n tokens = [stemmer.stem(t) for t in tweet.split()]\n return tokens","def tokenize(tweet):\n tweet = \" \".join(re.split(\"[^a-zA-Z]*\", tweet.lower())).strip()\n tokens = [stemmer.stem(t) for t in tweet.split()]\n return tokens","def tokenize(text, token):\n text = [token(x) for x in text]\n return text","def custom_tokenizer(self, nlp):\n # nlp.tokenizer = custom_tokenizer(nlp)\n return Tokenizer(\n nlp.vocab,\n prefix_search=regex.PREFIX_RE.search,\n suffix_search=regex.SUFFIX_RE.search,\n infix_finditer=regex.INFIX_RE.finditer,\n token_match=regex.SIMPLE_URL_RE.match,\n )","def spanish_tokenize(text):\n tokens = word_tokenize(text, 'spanish')\n stems = stem_tokens(tokens, stemmers['spanish'])\n stems = [i for i in stems if i not in punctuations]\n return stems","def _tokenize(self, text):\n if not text:\n return []\n\n text = PUNCTUATION_CHARS.sub(' ', text)\n\n words = [\n t[:128].lower() for t in text.split()\n if len(t) >= MIN_WORD_LENGTH and t.lower() not in STOP_WORDS\n ]\n\n return words","def tokenize(text):\n return [token.lower() for token in simple_preprocess(text) if token not in STOPWORDS]","def tokens_from_string(self, text):\n\n if self.level == \"character\":\n return list(text)\n elif self.level == \"word\":\n return nltk.word_tokenize(text)\n else:\n print(\"error: invalid level\")","def processes_and_tokenize(raw_document):\n\ttokenizer = RegexpTokenizer(r'\\w+')\n\ttokens = tokenizer.tokenize(raw_document.lower())\t\t# tokens = nltk.word_tokenize(corpus.lower()) # without removing punctiation\n\n\t#remove stop words\n\tstop_words = set(nltk.corpus.stopwords.words('english'))\n\t#stop_words = set(stopwords.words('english'))\n\tfiltered_tokens = [w for w in tokens if not w in stop_words]\n\treturn filtered_tokens","def tokenize_de(text):\n return [tok.text for tok in spacy_de.tokenizer(text)]","def tokenize_de(text):\n return [tok.text for tok in spacy_de.tokenizer(text)]","def tokenize_de(text):\n return [tok.text for tok in spacy_de.tokenizer(text)]","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n \n return clean_tokens","def tokenize(raw_text):\n def _xop(tokens):\n def _(x):\n return xop(x, \"op\", tokens)\n return _\n \n raw_tokens=xversa_split(raw_text, tokens=Op_Tokens+Group_Tokens)\n tokens=map(xtotype, raw_tokens) \n tokens=map(_xop(Op_Tokens+Group_Tokens), tokens)\n return tokens","def my_tokenize(sentence):\n sentence = sentence.lower()\n ll = word_tokenize(sentence)\n lls = [stemmer.stem(ii) for ii in ll if re.search(r'[a-z0-9]+', ii)]\n\n return lls","def tokenize(text):\n\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n \n clean_tokens =[]\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n\n return clean_tokens","def tokenize_text(text):\n tokens = []\n for sent in nltk.sent_tokenize(text):\n for word in nltk.word_tokenize(sent):\n if len(word) < 2:\n continue\n tokens.append(word.lower())\n return tokens","def process_text(text, stem=True):\n table = str.maketrans(\"\",\"\",string.punctuation) \n text = text.translate(table)\n tokens = word_tokenize(text)\n \n if stem:\n stemmer = PorterStemmer()\n tokens = [stemmer.stem(t) for t in tokens]\n \n return tokens","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n\n return clean_tokens","def _tokenize(self, text):\n if not text:\n return []\n\n text = self.PUNCTUATION_CHARS.sub(' ', text)\n\n words = [t[:128] for t in text.split() if len(t) >= self.MIN_WORD_LENGTH and t.lower() not in self.STOP_WORDS]\n\n return words","def process_text(text, stem=True):\n text = text.translate(str.maketrans('', '', string.punctuation))\n tokens = word_tokenize(text)\n \n if stem:\n stemmer = PorterStemmer()\n tokens = [stemmer.stem(t) for t in tokens]\n \n return tokens","def tokenize(text):\n text = re.sub('[^A-Za-z0-9]', ' ', text)\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n return clean_tokens","def tokenize(self, text: str) -> List[str]:\n\n # calls the selected tokenizer function e.g. 're' => re_tokenize(text)\n word_tokens = self.gpt2_tokenize(text)\n\n return word_tokens","def tokenize(text):\n text = text.translate(str.maketrans('', '', string.punctuation))\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n\n s = stopwords.words('english')\n result = []\n for token in clean_tokens:\n if token not in s:\n result.append(token)\n\n return result","def process_text(text, stem=True):\n exclude = set(string.punctuation)\n text = ''.join(ch for ch in text if ch not in exclude)\n #text = text.translate(None, string.punctuation)\n tokens = word_tokenize(text)\n if stem:\n stemmer = PorterStemmer()\n tokens = [stemmer.stem(t) for t in tokens]\n return tokens","def process_text(text, stem=True):\n table = string.maketrans(\"\",\"\")\n text = text.translate(table, string.punctuation)\n tokens = word_tokenize(text)\n \n if stem:\n stemmer = PorterStemmer()\n tokens = [stemmer.stem(t) for t in tokens]\n \n return tokens","def parse(self, tokenizer):\n pass","def tokenize(self, fileid):\n for paragraph in self.corpus.paras(fileids=fileid):\n yield [\n pos_tag(wordpunct_tokenize(sent))\n for sent in sent_tokenize(paragraph)\n ]","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for token in tokens:\n clean_token = lemmatizer.lemmatize(token).lower().strip()\n clean_tokens.append(clean_token)\n \n return clean_tokens","def tokenize(self, text):\n # Ignore non-ASCII characters.\n text = remove_non_ascii(text)\n text = text.translate(Tokenizer.trans)\n tokens = [t for t in text.split() \n if len(t) >= self._config[u'min_len']\n and t not in self._config[u'stopwords']]\n self._counter.update(tokens)","def tokenize(text):\n text = text.lower()\n text = re.sub(r\"[^a-zA-Z0-9]\", \" \", text)\n words = word_tokenize(text)\n words = [w for w in words if w not in stopwords.words(\"english\")]\n stemmed = [WordNetLemmatizer().lemmatize(w) for w in words]\n return(stemmed)","def word_tokenize(sentence, number_token=None, name_token=None, gpe_token=None):\n tokenized_sentence = nltk.word_tokenize(sentence)\n # Verify that the tokens are lowercase or none and then do the replacement\n _check_tokens(number_token, name_token, gpe_token)\n\n tokenized_sentence = number2token(tokenized_sentence, number_token)\n tagged_sentence = entities2token(tokenized_sentence, name_token, gpe_token)\n\n return tagged_sentence","def tokenize(self, fileids=None, categories=None):\n morph = pymorphy2.MorphAnalyzer()\n for paragraph in self.paras(fileids=fileids):\n yield [\n (word, morph.parse(word)[0].tag.POS)\n # pos_tag(wordpunct_tokenize(sent), lang='rus')\n for sent in sent_tokenize(paragraph)\n for word in wordpunct_tokenize(sent)\n ]","def process_text(text):\n text = text.translate(translator)\n tokens = word_tokenize(text)\n# if stem:\n stemmer = PorterStemmer()\n tokens = [stemmer.stem(t) for t in tokens]\n \n return tokens","def _tokenize(ustr1):\n\n return list(tk.generate_tokens(io.StringIO(ustr1).readline))","def tokenize(text):\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for token in tokens:\n clean_token = lemmatizer.lemmatize(token).lower().strip()\n clean_tokens.append(clean_token)\n\n return clean_tokens","def tokenize(text):\n text = re.sub(r\"[^a-zA-Z0-9]+\", \" \", text.lower())\n\n tokens = word_tokenize(text)\n lemmatizer = WordNetLemmatizer()\n\n clean_tokens = []\n for tok in tokens:\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\n clean_tokens.append(clean_tok)\n\n return clean_tokens"],"string":"[\n \"def gpt2_tokenize(self, text: str):\\n return self.bpe_tokenize(text)\",\n \"def preprocess(text):\\n\\tX = []\\n\\tsent_detector = nltk.data.load('tokenizers/punkt/english.pickle')\\n\\tfor t in text:\\n\\t\\tsents = sent_detector.tokenize(t)\\n\\t\\tresult = ''\\n\\t\\tfor s in sents:\\n\\t\\t\\ttokens = word_tokenize(s)\\n\\t\\t\\tresult += ' ' + ' '.join(tokens)\\n\\t\\tX.append(result)\\n\\treturn X\",\n \"def sentence_tokenizer(text):\\n return sent_tokenize(text)\",\n \"def tokenize(sentence):\\n return nltk.word_tokenize(sentence)\",\n \"def preprocess_sent(sent):\\n #tokenized = word_tokenize(sent.lower())\\n tokenizer = Tok()\\n tokenized = tokenizer.tokenize(sent.lower())\\n return tokenized\",\n \"def train_punkt_sent_tokenizer(train_ref,train_pickle):\\r\\n\\timport nltk.tokenize.punkt\\r\\n\\ttokenizer = nltk.tokenize.punkt.PunktSentenceTokenizer()\\r\\n\\t\\r\\n\\t# read training corpus\\r\\n\\timport codecs\\r\\n\\ttext = codecs.open(train_ref).read()\\r\\n\\ttokenizer.train(text)\\r\\n\\r\\n\\t# dump pickled tokenizer\\r\\n\\timport pickle\\r\\n\\tout = open(train_pickle,\\\"wb\\\")\\r\\n\\tpickle.dump(tokenizer, out)\\r\\n\\tout.close()\",\n \"def tokenize(text):\\n lowers = text.lower()\\n trans = {ord(c): None for c in string.punctuation}\\n no_punctuation = lowers.translate(trans)\\n trans_dig = {ord(c): None for c in string.digits}\\n no_digits = no_punctuation.translate(trans_dig)\\n tokens = nltk.word_tokenize(no_digits)\\n return tokens\",\n \"def tokenize_text(text):\\n return nltk.tokenize.word_tokenize(text)\",\n \"def tokenize(raw_text):\\n tokenized_text = nltk.tokenize.word_tokenize(raw_text)\\n return tokenized_text\",\n \"def tokenize(text):\\n text = text.decode('utf-8')\\n return nltk.word_tokenize(text)\",\n \"def tokenize_pt(text):\\n #primeiros padrões, separação de palavra de [. , ? ! ( ) [ ] : ; ' ' \\\" \\\" ]\\n return split_level_two(split_level_one(text))\",\n \"def tokenize(self, start_pos=0, text=None):\\n pass\",\n \"def tokenize(sentence):\\n tokens = nltk.word_tokenize(sentence)\\n return tokens\",\n \"def tokenize(text):\\n sentence = Sentence(text)\\n return sentence.tokens()\",\n \"def get_tokens(sent):\\n return word_tokenize(sent)\",\n \"def tokenize (self, text):\\n if self.type == \\\"gpt2\\\":\\n return self._tokenizer.tokenize(text)\\n if self.type == \\\"bpe\\\":\\n return self._tokenizer.EncodeAsPieces(text)\",\n \"def _tokenize(self, text: str) -> List[str]:\\n return self.bert_model.tokenize(text.strip())\",\n \"def _tokenize(self, text: str) -> List[str]:\\n return self.bpe.tokenize(text)\",\n \"def _tokenize(text, language_code):\\n seq = annotool.raw2basicseq(text, language_code, pos=False)\\n word_seq = seq['word']\\n return word_seq\",\n \"def tokenize(txt):\\n Depunc = depunctuate(txt).lower()\\n Tokens = word_tokenize(Depunc)\\n \\n return Tokens\",\n \"def wordpunct_space_tokenize(sent):\\n return _rts.tokenize(sent)\",\n \"def tokenize(text):\\n #Clean data, remove all character except character and number,such as punctuation etc.\\n text = re.sub(r'[^a-zA-Z0-9]', ' ', text.lower())\\n tokens = word_tokenize(text)\\n tokens = [WordNetLemmatizer().lemmatize(word) for word in tokens if word not in ST_english]\\n return tokens\",\n \"def simple_tokenizer(text):\\n re_tok = re.compile(punctuation_string)\\n return re_tok.sub(' ', text).split()\",\n \"def english_tokenzier(text: str):\\n TOKENIZER = ToktokTokenizer().tokenize\\n return TOKENIZER(text)\",\n \"def naive(self, text):\\n\\t\\t#print(text)\\n\\t\\ttokenizedText = []\\n\\t\\tfor k in text: #look at each entity in one sentence\\n\\t\\t\\t\\n\\t\\t\\ta = \\\"\\\"#stores the current word \\n\\t\\t\\trun = []; #appends all words in a particular sentence\\n\\t\\t\\tfor i in range(len(k)):\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif(k[i] == ' ' or k[i] == '\\t'): #tokenization at space or tab\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif(a!=\\\"\\\"):\\n\\t\\t\\t\\t\\t\\tif(a[-1] == ',' or a[-1] == '-' or a[-1] == \\\"\\\\'\\\" or a[-1] == \\\";\\\" or a[-1] == \\\":\\\" or a[-1] ==\\\"!\\\" or a[-1] == \\\"?\\\" or a[-1] ==\\\"\\\\\\\"\\\") : #but remove mentioned punctuations from the end of the word, if present\\n\\t\\t\\t\\t\\t\\t\\ta = a[:-1]\\n\\t\\t\\t\\t\\t\\tif(len(a)>0 and a[0] == \\\"\\\\\\\"\\\"):#remove starting quotes\\n\\t\\t\\t\\t\\t\\t\\ta = a[1:]\\n\\t\\t\\t\\t\\t\\tif(len(a)>0):\\n\\t\\t\\t\\t\\t\\t\\trun.append(a)\\n\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\ta = \\\"\\\"\\n\\n\\n\\t\\t\\t\\telif(i == len(k)-1): #remove the last punctuation mark, if present\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\ta = a+k[i];\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif(a[-1] == '.' or a[-1] == '\\\\\\\"' or a[-1] ==\\\"!\\\" or a[-1] == \\\"?\\\" or a[-1] ==\\\"\\\\'\\\" ):\\n\\t\\t\\t\\t\\t\\ta = a[:-1]\\n\\t\\t\\t\\t\\tif(len(a)>0 and a[0] == \\\"\\\\\\\"\\\"):\\n\\t\\t\\t\\t\\t\\ta = a[1:]\\n\\t\\t\\t\\t\\tif(len(a)>0):\\n\\t\\t\\t\\t\\t\\trun.append(a)\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\ta = \\\"\\\"\\n\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif((k[i] == ',' or k[i] == ':' or k[i] == ';') and k[i+1]!= ' ' ): # for other punctuation marks followed by a space\\n\\t\\t\\t\\t\\t\\t#print(k[i-1])\\n\\t\\t\\t\\t\\t\\tif(len(a)>0):\\n\\t\\t\\t\\t\\t\\t\\tif(a[-1] == '\\\\\\\"' or a[-1] ==\\\"!\\\" or a[-1] == \\\"?\\\" ):\\n\\t\\t\\t\\t\\t\\t\\t\\ta = a[:-1]\\n\\t\\t\\t\\t\\t\\t\\tif(len(a)>0 and a[0] == \\\"\\\\\\\"\\\"):\\n\\t\\t\\t\\t\\t\\t\\t\\ta = a[1:]\\n\\t\\t\\t\\t\\t\\t\\tif(len(a)>0):\\n\\t\\t\\t\\t\\t\\t\\t\\trun.append(a)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\t\\ta = \\\"\\\"\\n\\n\\n\\t\\t\\t\\t\\telse:\\n\\n\\t\\t\\t\\t\\t\\ta = a+k[i];\\n\\n\\t\\t\\ttokenizedText.append(run)\\t\\t\\n\\n\\t\\t\\n\\t\\t\\t\\n\\n\\n\\n\\n\\t\\t#Fill in code here\\n\\n\\t\\treturn tokenizedText\",\n \"def _tokenize(self, text: str) -> List[str]:\\n text = text.lower().strip()\\n return self.bpe.tokenize(text)\",\n \"def tokenize(text):\\n wt = nltk.RegexpTokenizer(pattern=r'\\\\s+', gaps=True)\\n tokens = wt.tokenize(text)\\n return tokens\",\n \"def tokenize_text(document, nlp):\\n\\n return [token.text for token in nlp(document)]\",\n \"def custom_tokenizer(nlp, infix_reg):\\n return Tokenizer(nlp.vocab, infix_finditer=infix_reg.finditer)\",\n \"def tokenize(self, text, **kwargs):\\n if self.opt['tracker'] == 'babi6':\\n text = babi6_dirty_fix(text)\\n text = text.replace('<SILENCE>', '_SILENCE_')\\n\\n return [t.text for t in NLP.tokenizer(text)]\",\n \"def tokenize(text):\\n tokens=word_tokenize(text)\\n lemmatizer=WordNetLemmatizer()\\n \\n clean_tokens=[]\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n return clean_tokens\\n pass\",\n \"def tokenize(text):\\n text = text.lower()\\n remove = re.compile('[' + string.punctuation + '0-9\\\\\\\\r\\\\\\\\t\\\\\\\\n]')\\n cleanText = re.sub(remove, \\\" \\\", text)\\n tokens = nltk.word_tokenize(cleanText)\\n tokens = [w.lower() for w in tokens if (len(w) >= 3 and w not in ENGLISH_STOP_WORDS)]\\n return tokens\",\n \"def tokenize(review):\\n\\n token = strip_multiple_whitespaces(strip_punctuation(review))\\n return [token.split() for token in simple_preprocess(token) if token not in STOPWORDS]\",\n \"def tokenize(text):\\n tokens = TreebankWordTokenizer().tokenize(text)\\n tokens = lemmatize(tokens)\\n tokens = filter(lambda s: len(s) > 2, tokens) # remove tokens with < 3 chars\\n return tokens\",\n \"def tokenize(text):\\n return text.split(' ')\",\n \"def tokenize_and_stem(doc):\\n punctuation_remover = dict((ord(char), None) for char in string.punctuation)\\n tokens = nltk.word_tokenize(doc.lower().translate(punctuation_remover))\\n return PlagiarismDetector.stem_tokens(tokens)\",\n \"def tokenize(text):\\n \\n #regular expression to avoid pucntuations or any special character\\n tokenizer = nltk.RegexpTokenizer(r\\\"\\\\w+\\\")\\n \\n #tokenizing text\\n tokens = tokenizer.tokenize(text)\\n \\n #initiating lemmatizer\\n lemmatizer = WordNetLemmatizer()\\n \\n #iteratating through each token\\n clean_tokens = []\\n for tok in tokens:\\n \\n #stop words are irrelevant in this context of classifying response\\n if (tok.lower() not in stopwords.words(\\\"english\\\")):\\n \\n # lemmatizing, normalizing case, and removing leading/trailing white space\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n \\n return clean_tokens\",\n \"def tokenize(text):\\n \\n #regular expression to avoid pucntuations or any special character\\n tokenizer = nltk.RegexpTokenizer(r\\\"\\\\w+\\\")\\n \\n #tokenizing text\\n tokens = tokenizer.tokenize(text)\\n \\n #initiating lemmatizer\\n lemmatizer = WordNetLemmatizer()\\n \\n #iteratating through each token\\n clean_tokens = []\\n for tok in tokens:\\n \\n #stop words are irrelevant in this context of classifying response\\n if (tok.lower() not in stopwords.words(\\\"english\\\")):\\n \\n # lemmatizing, normalizing case, and removing leading/trailing white space\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n \\n return clean_tokens\",\n \"def tokenizer(self):\\n tokenizer = RegexpTokenizer(r'\\\\w+')\\n \\n self.tweet_tokenized_train = [tokenizer.tokenize(x.lower()) for x in self.tweet_prepro_train]\\n self.tweet_tokenized_test = [tokenizer.tokenize(x.lower()) for x in self.tweet_prepro_test]\",\n \"def tokenizer(s):\\n\\n tokens = tokenize(s.lower()) # apply the nltk tokenizer\\n tokens = [t for t in tokens if doc_frequency[t]>5 and t not in stop_words]# and doc_frequency[t]<3000]\\n \\n return tokens\",\n \"def tokenize(self, text):\\n\\n text = convert_to_unicode(text)\\n\\n output_tokens = []\\n for token in whitespace_tokenize(text):\\n chars = list(token)\\n if len(chars) > self.max_input_chars_per_word:\\n output_tokens.append(self.unk_token)\\n continue\\n\\n is_bad = False\\n start = 0\\n sub_tokens = []\\n while start < len(chars):\\n end = len(chars)\\n cur_substr = None\\n while start < end:\\n substr = \\\"\\\".join(chars[start:end])\\n ### joonho.lim @ 2019-03-15\\n # if start > 0:\\n # substr = \\\"##\\\" + substr\\n # print ( '[substr]\\\\t%s\\\\t%s\\\\t%d\\\\t%d' % ( substr, substr in self.vocab, start, end))\\n if substr in self.vocab:\\n cur_substr = substr\\n break\\n end -= 1\\n if cur_substr is None:\\n is_bad = True\\n break\\n sub_tokens.append(cur_substr)\\n start = end\\n\\n if is_bad:\\n output_tokens.append(self.unk_token)\\n else:\\n output_tokens.extend(sub_tokens)\\n output_tokens.insert(0, '[CLS]')\\n output_tokens.append('[SEP]')\\n return output_tokens\",\n \"def tokenize(text: str):\\n # Create list of word tokens\\n token_list = []\\n # nlp = init_nlp(TaggingMethod.SPACY, Lang.ES, size=DictionarySize.MEDIUM)\\n doc = nlp(text)\\n token_list = [token.text for token in doc]\\n # for token in doc:\\n # token_list.append(token.text)\\n return token_list\",\n \"def pre_process(text):\\n # replace (,.'\\\") with ''\\n text = text.replace(',', '')\\n text = text.replace('.', '')\\n text = text.replace(\\\"'\\\", '')\\n text = text.replace(\\\"\\\\\\\"\\\", '')\\n\\n # tokenize into words\\n tokens = [word for sent in sent_tokenize(text) for word in word_tokenize(sent)]\\n\\n # remove stopwords\\n stop = stopwords.words('english')\\n tokens = [token for token in tokens if token not in stop]\\n\\n # remove words less than three letters\\n tokens = [word for word in tokens if len(word) >= 3]\\n\\n # lower capitalization\\n tokens = [word.lower() for word in tokens]\\n\\n # lemmatize\\n lmtzr = WordNetLemmatizer()\\n tokens = [lmtzr.lemmatize(word) for word in tokens]\\n\\n return tokens\",\n \"def detokenize(tokens):\\n pass\",\n \"def basic_tokenize(tweet):\\n tweet = \\\" \\\".join(re.split(\\\"[^a-zA-Z.,!?]*\\\", tweet.lower())).strip()\\n return tweet.split()\",\n \"def process_token_sentence(text):\\n\\n sentences = nltk.sent_tokenize(text)\\n tokenized_sentences = [nltk.word_tokenize(sentence) for sentence in sentences]\\n tagged_sentences = [nltk.pos_tag(sentence) for sentence in tokenized_sentences]\\n sentences = nltk.ne_chunk_sents(tagged_sentences, binary=True)\\n\\n return sentences\",\n \"def tokenize(t):\\n tweet_tok = TweetTokenizer(strip_handles=True, reduce_len=True)\\n tokens = tweet_tok.tokenize(t)\\n wnl = WordNetLemmatizer()\\n stems = []\\n for item in tokens:\\n stems.append(wnl.lemmatize(item))\\n return stems\",\n \"def tokenize(src):\\n\\n pass\",\n \"def _word_tokenize_spacy(sent):\\n tokens = SQuADDataTokenizer._spacy_tokenizer(sent)\\n return tokens\",\n \"def tokenize(sentence):\\n lower_s = sentence.lower()\\n no_punc_s = lower_s.translate(TRANS, string.punctuation)\\n\\n word_list = no_punc_s.split()\\n\\n return word_list\",\n \"def english_tokenize(text):\\n tokens = word_tokenize(text, 'english')\\n stems = stem_tokens(tokens, stemmers['english'])\\n stems = [i for i in stems if i not in punctuations]\\n return stems\",\n \"def _tokenize(self, text):\\n bpe_tokens = []\\n for token in re.findall(self.pat, text):\\n bpe_tokens.extend([t for t in self.bpe(token).split(\\\" \\\")])\\n return bpe_tokens\",\n \"def tokenize(text):\\n global TOK\\n tokens = TOK.tokenize(text)\\n output = {\\n 'words': tokens.words(),\\n 'offsets': tokens.offsets(),\\n 'pos': tokens.pos(),\\n 'lemma': tokens.lemmas(),\\n 'ner': tokens.entities(),\\n }\\n return output\",\n \"def tokenize(text):\\n\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n return [lemmatizer.lemmatize(token).lower().strip() for token in tokens]\",\n \"def tokenize(text):\\n \\n text.lower() # convert to lowercase\\n text = re.sub(r\\\"[^a-zA-Z0-9]\\\", \\\" \\\", text) #remove punctuation\\n words = word_tokenize(text) # tokenize by individual word\\n words = [w for w in words if w not in stopwords.words(\\\"english\\\")] #remove stop words\\n lemmed = [WordNetLemmatizer().lemmatize(w) for w in words] #lemminization\\n \\n return words\",\n \"def sentence_tokenize(tokenizer, sent):\\n tokens = tokenizer.EncodeAsIds(sent).tokenization\\n return tokens\",\n \"def tokenize(doc):\\n\\n # Calls NLTK function to tokenize the document. Broken into individual words, cleans out punctuation\\n tokens = nltk.word_tokenize(doc)\\n\\n return tokens\",\n \"def tokenize(self, text):\\n # text = convert_to_unicode(text)\\n\\n output_tokens = []\\n for token in split_by_whitespace(text):\\n chars = list(token)\\n if len(chars) > self.max_input_chars_per_word:\\n output_tokens.append(self.unk_token)\\n continue\\n\\n is_bad = False\\n start = 0\\n sub_tokens = []\\n while start < len(chars):\\n end = len(chars)\\n cur_substr = None\\n while start < end:\\n substr = \\\"\\\".join(chars[start:end])\\n if start > 0:\\n substr = \\\"##\\\" + substr\\n if substr in self.vocab:\\n cur_substr = substr\\n break\\n end -= 1\\n if cur_substr is None:\\n is_bad = True\\n break\\n sub_tokens.append(cur_substr)\\n start = end\\n\\n if is_bad:\\n output_tokens.append(self.unk_token)\\n else:\\n output_tokens.extend(sub_tokens)\\n return output_tokens\",\n \"def ie_preprocess(document):\\n sentences = nltk.sent_tokenize(document) #NLTK default sentence segmenter\\n #print sentences # sentences are segmented\\n sentences = [nltk.word_tokenize(sent) for sent in sentences] # NLTK word tokenizer \\n #print sentences # sentences are tokenized\\n sentences = [nltk.pos_tag(sent) for sent in sentences] # NLTK POS tagger \\n #print sentences # sentences are POS tagged\\n return sentences\",\n \"def preprocess_document(raw,sentence_level):\\r\\n\\r\\n\\t# raw = raw.decode(\\\"utf-8\\\")\\r\\n\\t# raw = raw.encode(\\\"ascii\\\",\\\"ignore\\\")\\r\\n\\t\\r\\n\\tfrom nltk.tokenize.punkt import PunktSentenceTokenizer, PunktParameters\\r\\n\\tparam = PunktParameters()\\r\\n\\ttokenizer = PunktSentenceTokenizer(param)\\r\\n\\tif sentence_level:\\r\\n\\t\\tsentences = tokenizer.tokenize(raw)\\r\\n\\t\\tsentences_words = list()\\r\\n\\t\\tfor s in sentences:\\r\\n\\t\\t\\tsentences_words.append((s.strip(),preprocess_sentence(s)))\\r\\n\\t\\treturn sentences_words\\r\\n\\telse:\\r\\n\\t\\treturn [(raw.strip(),preprocess_sentence(raw))]\",\n \"def word_tokenize(text):\\n word_list = []\\n for sentences in nltk.sent_tokenize(text):\\n for words in nltk.word_tokenize(sentences):\\n word_list.append(words)\\n return word_list\",\n \"def identity_tokenizer(text):\\n return text\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n clean_tokens = []\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n return clean_tokens\",\n \"def tokenization(text):\\n\\n global tokenizer_tree\\n tokenised_document = tokenizer_tree.tokenize(text)\\n return tokenised_document\",\n \"def tokenize(tweet):\\n tweet = \\\" \\\".join(re.split(\\\"[^a-zA-Z]*\\\", tweet.lower())).strip()\\n tokens = [stemmer.stem(t) for t in tweet.split()]\\n return tokens\",\n \"def tokenize(tweet):\\n tweet = \\\" \\\".join(re.split(\\\"[^a-zA-Z]*\\\", tweet.lower())).strip()\\n tokens = [stemmer.stem(t) for t in tweet.split()]\\n return tokens\",\n \"def tokenize(text, token):\\n text = [token(x) for x in text]\\n return text\",\n \"def custom_tokenizer(self, nlp):\\n # nlp.tokenizer = custom_tokenizer(nlp)\\n return Tokenizer(\\n nlp.vocab,\\n prefix_search=regex.PREFIX_RE.search,\\n suffix_search=regex.SUFFIX_RE.search,\\n infix_finditer=regex.INFIX_RE.finditer,\\n token_match=regex.SIMPLE_URL_RE.match,\\n )\",\n \"def spanish_tokenize(text):\\n tokens = word_tokenize(text, 'spanish')\\n stems = stem_tokens(tokens, stemmers['spanish'])\\n stems = [i for i in stems if i not in punctuations]\\n return stems\",\n \"def _tokenize(self, text):\\n if not text:\\n return []\\n\\n text = PUNCTUATION_CHARS.sub(' ', text)\\n\\n words = [\\n t[:128].lower() for t in text.split()\\n if len(t) >= MIN_WORD_LENGTH and t.lower() not in STOP_WORDS\\n ]\\n\\n return words\",\n \"def tokenize(text):\\n return [token.lower() for token in simple_preprocess(text) if token not in STOPWORDS]\",\n \"def tokens_from_string(self, text):\\n\\n if self.level == \\\"character\\\":\\n return list(text)\\n elif self.level == \\\"word\\\":\\n return nltk.word_tokenize(text)\\n else:\\n print(\\\"error: invalid level\\\")\",\n \"def processes_and_tokenize(raw_document):\\n\\ttokenizer = RegexpTokenizer(r'\\\\w+')\\n\\ttokens = tokenizer.tokenize(raw_document.lower())\\t\\t# tokens = nltk.word_tokenize(corpus.lower()) # without removing punctiation\\n\\n\\t#remove stop words\\n\\tstop_words = set(nltk.corpus.stopwords.words('english'))\\n\\t#stop_words = set(stopwords.words('english'))\\n\\tfiltered_tokens = [w for w in tokens if not w in stop_words]\\n\\treturn filtered_tokens\",\n \"def tokenize_de(text):\\n return [tok.text for tok in spacy_de.tokenizer(text)]\",\n \"def tokenize_de(text):\\n return [tok.text for tok in spacy_de.tokenizer(text)]\",\n \"def tokenize_de(text):\\n return [tok.text for tok in spacy_de.tokenizer(text)]\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n \\n return clean_tokens\",\n \"def tokenize(raw_text):\\n def _xop(tokens):\\n def _(x):\\n return xop(x, \\\"op\\\", tokens)\\n return _\\n \\n raw_tokens=xversa_split(raw_text, tokens=Op_Tokens+Group_Tokens)\\n tokens=map(xtotype, raw_tokens) \\n tokens=map(_xop(Op_Tokens+Group_Tokens), tokens)\\n return tokens\",\n \"def my_tokenize(sentence):\\n sentence = sentence.lower()\\n ll = word_tokenize(sentence)\\n lls = [stemmer.stem(ii) for ii in ll if re.search(r'[a-z0-9]+', ii)]\\n\\n return lls\",\n \"def tokenize(text):\\n\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n \\n clean_tokens =[]\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n\\n return clean_tokens\",\n \"def tokenize_text(text):\\n tokens = []\\n for sent in nltk.sent_tokenize(text):\\n for word in nltk.word_tokenize(sent):\\n if len(word) < 2:\\n continue\\n tokens.append(word.lower())\\n return tokens\",\n \"def process_text(text, stem=True):\\n table = str.maketrans(\\\"\\\",\\\"\\\",string.punctuation) \\n text = text.translate(table)\\n tokens = word_tokenize(text)\\n \\n if stem:\\n stemmer = PorterStemmer()\\n tokens = [stemmer.stem(t) for t in tokens]\\n \\n return tokens\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n\\n return clean_tokens\",\n \"def _tokenize(self, text):\\n if not text:\\n return []\\n\\n text = self.PUNCTUATION_CHARS.sub(' ', text)\\n\\n words = [t[:128] for t in text.split() if len(t) >= self.MIN_WORD_LENGTH and t.lower() not in self.STOP_WORDS]\\n\\n return words\",\n \"def process_text(text, stem=True):\\n text = text.translate(str.maketrans('', '', string.punctuation))\\n tokens = word_tokenize(text)\\n \\n if stem:\\n stemmer = PorterStemmer()\\n tokens = [stemmer.stem(t) for t in tokens]\\n \\n return tokens\",\n \"def tokenize(text):\\n text = re.sub('[^A-Za-z0-9]', ' ', text)\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n return clean_tokens\",\n \"def tokenize(self, text: str) -> List[str]:\\n\\n # calls the selected tokenizer function e.g. 're' => re_tokenize(text)\\n word_tokens = self.gpt2_tokenize(text)\\n\\n return word_tokens\",\n \"def tokenize(text):\\n text = text.translate(str.maketrans('', '', string.punctuation))\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n\\n s = stopwords.words('english')\\n result = []\\n for token in clean_tokens:\\n if token not in s:\\n result.append(token)\\n\\n return result\",\n \"def process_text(text, stem=True):\\n exclude = set(string.punctuation)\\n text = ''.join(ch for ch in text if ch not in exclude)\\n #text = text.translate(None, string.punctuation)\\n tokens = word_tokenize(text)\\n if stem:\\n stemmer = PorterStemmer()\\n tokens = [stemmer.stem(t) for t in tokens]\\n return tokens\",\n \"def process_text(text, stem=True):\\n table = string.maketrans(\\\"\\\",\\\"\\\")\\n text = text.translate(table, string.punctuation)\\n tokens = word_tokenize(text)\\n \\n if stem:\\n stemmer = PorterStemmer()\\n tokens = [stemmer.stem(t) for t in tokens]\\n \\n return tokens\",\n \"def parse(self, tokenizer):\\n pass\",\n \"def tokenize(self, fileid):\\n for paragraph in self.corpus.paras(fileids=fileid):\\n yield [\\n pos_tag(wordpunct_tokenize(sent))\\n for sent in sent_tokenize(paragraph)\\n ]\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for token in tokens:\\n clean_token = lemmatizer.lemmatize(token).lower().strip()\\n clean_tokens.append(clean_token)\\n \\n return clean_tokens\",\n \"def tokenize(self, text):\\n # Ignore non-ASCII characters.\\n text = remove_non_ascii(text)\\n text = text.translate(Tokenizer.trans)\\n tokens = [t for t in text.split() \\n if len(t) >= self._config[u'min_len']\\n and t not in self._config[u'stopwords']]\\n self._counter.update(tokens)\",\n \"def tokenize(text):\\n text = text.lower()\\n text = re.sub(r\\\"[^a-zA-Z0-9]\\\", \\\" \\\", text)\\n words = word_tokenize(text)\\n words = [w for w in words if w not in stopwords.words(\\\"english\\\")]\\n stemmed = [WordNetLemmatizer().lemmatize(w) for w in words]\\n return(stemmed)\",\n \"def word_tokenize(sentence, number_token=None, name_token=None, gpe_token=None):\\n tokenized_sentence = nltk.word_tokenize(sentence)\\n # Verify that the tokens are lowercase or none and then do the replacement\\n _check_tokens(number_token, name_token, gpe_token)\\n\\n tokenized_sentence = number2token(tokenized_sentence, number_token)\\n tagged_sentence = entities2token(tokenized_sentence, name_token, gpe_token)\\n\\n return tagged_sentence\",\n \"def tokenize(self, fileids=None, categories=None):\\n morph = pymorphy2.MorphAnalyzer()\\n for paragraph in self.paras(fileids=fileids):\\n yield [\\n (word, morph.parse(word)[0].tag.POS)\\n # pos_tag(wordpunct_tokenize(sent), lang='rus')\\n for sent in sent_tokenize(paragraph)\\n for word in wordpunct_tokenize(sent)\\n ]\",\n \"def process_text(text):\\n text = text.translate(translator)\\n tokens = word_tokenize(text)\\n# if stem:\\n stemmer = PorterStemmer()\\n tokens = [stemmer.stem(t) for t in tokens]\\n \\n return tokens\",\n \"def _tokenize(ustr1):\\n\\n return list(tk.generate_tokens(io.StringIO(ustr1).readline))\",\n \"def tokenize(text):\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for token in tokens:\\n clean_token = lemmatizer.lemmatize(token).lower().strip()\\n clean_tokens.append(clean_token)\\n\\n return clean_tokens\",\n \"def tokenize(text):\\n text = re.sub(r\\\"[^a-zA-Z0-9]+\\\", \\\" \\\", text.lower())\\n\\n tokens = word_tokenize(text)\\n lemmatizer = WordNetLemmatizer()\\n\\n clean_tokens = []\\n for tok in tokens:\\n clean_tok = lemmatizer.lemmatize(tok).lower().strip()\\n clean_tokens.append(clean_tok)\\n\\n return clean_tokens\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7247982","0.7229188","0.7094783","0.70895004","0.70805717","0.69946355","0.6974862","0.6922694","0.6919841","0.68694","0.6835729","0.6791642","0.67796576","0.6747571","0.6684571","0.66801494","0.6662924","0.6644727","0.66325396","0.6598598","0.6588903","0.65691334","0.65586853","0.6558186","0.6549853","0.6478443","0.64611876","0.64549243","0.6454689","0.644867","0.64195466","0.6407422","0.64037126","0.6390652","0.63852113","0.6379052","0.63688165","0.63688165","0.6366419","0.6366204","0.63631684","0.6355827","0.6348684","0.63484967","0.6342229","0.6333818","0.6308071","0.63023174","0.63005716","0.6291695","0.6281657","0.62743795","0.62678057","0.6227588","0.6225919","0.6219901","0.6208961","0.62062466","0.62051904","0.62049043","0.6204524","0.62026596","0.6202526","0.61996126","0.6196428","0.6196428","0.6191171","0.61894536","0.6186232","0.61860377","0.6180211","0.61750156","0.6167292","0.61640924","0.61640924","0.61640924","0.6163359","0.6163207","0.61618376","0.61612433","0.61531717","0.6151722","0.6148146","0.61473435","0.6137973","0.61277336","0.61272985","0.612609","0.61227787","0.61217695","0.6118919","0.61144996","0.61115485","0.61046946","0.60973305","0.6092075","0.60884213","0.6085781","0.60843825","0.6069151","0.60649437"],"string":"[\n \"0.7247982\",\n \"0.7229188\",\n \"0.7094783\",\n \"0.70895004\",\n \"0.70805717\",\n \"0.69946355\",\n \"0.6974862\",\n \"0.6922694\",\n \"0.6919841\",\n \"0.68694\",\n \"0.6835729\",\n \"0.6791642\",\n \"0.67796576\",\n \"0.6747571\",\n \"0.6684571\",\n \"0.66801494\",\n \"0.6662924\",\n \"0.6644727\",\n \"0.66325396\",\n \"0.6598598\",\n \"0.6588903\",\n \"0.65691334\",\n \"0.65586853\",\n \"0.6558186\",\n \"0.6549853\",\n \"0.6478443\",\n \"0.64611876\",\n \"0.64549243\",\n \"0.6454689\",\n \"0.644867\",\n \"0.64195466\",\n \"0.6407422\",\n \"0.64037126\",\n \"0.6390652\",\n \"0.63852113\",\n \"0.6379052\",\n \"0.63688165\",\n \"0.63688165\",\n \"0.6366419\",\n \"0.6366204\",\n \"0.63631684\",\n \"0.6355827\",\n \"0.6348684\",\n \"0.63484967\",\n \"0.6342229\",\n \"0.6333818\",\n \"0.6308071\",\n \"0.63023174\",\n \"0.63005716\",\n \"0.6291695\",\n \"0.6281657\",\n \"0.62743795\",\n \"0.62678057\",\n \"0.6227588\",\n \"0.6225919\",\n \"0.6219901\",\n \"0.6208961\",\n \"0.62062466\",\n \"0.62051904\",\n \"0.62049043\",\n \"0.6204524\",\n \"0.62026596\",\n \"0.6202526\",\n \"0.61996126\",\n \"0.6196428\",\n \"0.6196428\",\n \"0.6191171\",\n \"0.61894536\",\n \"0.6186232\",\n \"0.61860377\",\n \"0.6180211\",\n \"0.61750156\",\n \"0.6167292\",\n \"0.61640924\",\n \"0.61640924\",\n \"0.61640924\",\n \"0.6163359\",\n \"0.6163207\",\n \"0.61618376\",\n \"0.61612433\",\n \"0.61531717\",\n \"0.6151722\",\n \"0.6148146\",\n \"0.61473435\",\n \"0.6137973\",\n \"0.61277336\",\n \"0.61272985\",\n \"0.612609\",\n \"0.61227787\",\n \"0.61217695\",\n \"0.6118919\",\n \"0.61144996\",\n \"0.61115485\",\n \"0.61046946\",\n \"0.60973305\",\n \"0.6092075\",\n \"0.60884213\",\n \"0.6085781\",\n \"0.60843825\",\n \"0.6069151\",\n \"0.60649437\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3184,"cells":{"query":{"kind":"string","value":"boolean of if changes have been made to present sha"},"document":{"kind":"string","value":"def dirty(cls):\n output = subprocess.check_output(DIRTY_INCANTATION)\n return len(output.strip()) == 0"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def has_changes(self):\n if self.repo_is_empty:\n return True\n\n tree = self.repo.get(self.index.write_tree(self.repo))\n diff = tree.diff_to_tree(self.repo.get(self.repo.head.target).tree)\n return bool(diff)","def index_is_dirty():\n result, output = popen('git diff --cached', False, False)\n return len(output) > 0","def is_rev_dirty(ctx: \"PlanemoCliContext\", directory: str) -> bool:\n return io.shell([\"git\", \"diff\", \"--quiet\"], cwd=directory) != 0","def is_changed(self, include_md: bool = True) -> bool:\n current = self.calculate_hash(include_md=include_md)\n stored = self.hash if include_md else self.stub_hash\n log.trace(f\"changed = {self.hash != current} | Stored: {stored} | Current: {current}\")\n return stored != current","def is_sha(self):\n return self.name.startswith('SHA')","def local_changes():\n result, output = popen('git status', False, False)\n try:\n return not output[-1].startswith(\"nothing to commit\")\n except IndexError:\n return True","def consistent(self):\n return self.incore_digest == self.ondisk_digest","def hash_comparison(self):\n for result in self.cards:\n if result.hash_status:\n return True\n return False","def _is_commit_sha(commit):\n return len(commit) == 40 and all([\n ch.isdigit() or (ch >= \"a\" and ch <= \"f\")\n for ch in commit.elems()\n ])","def dirty(self) -> bool:\n return len(self.detect_changed_files()) != 0","def check(self) -> bool:\n return self.check_sum() == self.__md5_sum","def hasChanged(self):\n return ((self.mtime != getmtime(self.path)) or\n (self.size != os.path.getsize(self.path)) )","def isOpen(self):\n return self.analyzed_digest != {}","def needs_update(self, cache_key):\r\n return self._read_sha(cache_key) != cache_key.hash","def is_git_sha(text):\n # Handle both the full sha as well as the 7-character abbreviation\n if len(text) in (40, 7):\n try:\n int(text, 16)\n return True\n except ValueError:\n pass\n return False","def _check_md5(self):\n\n self.log.info('-' * 80)\n self.log.info('Check md5 sum')\n\n self.log.info(self._ref_value)\n self.log.info(self._output_file)\n\n code, out = cmd_exec(['md5sum', self._output_file], shell=False, log=self.log)\n if code:\n self.log.error(out)\n return False\n self.log.info(out)\n\n md5sum, _ = out.split(' ')\n\n self.log.info(f'reference md5: {self._ref_value}')\n self.log.info(f'actual md5: {md5sum}')\n\n if self._ref_value != md5sum:\n return False\n\n return True","def has_changes(directory=None):\n out = check_output('git status', shell=True, cwd=directory)\n if 'nothing to commit (working directory clean)' in out:\n return False\n if 'nothing to commit, working directory clean' in out:\n return False\n if 'nothing to commit, working tree clean' in out:\n return False\n if 'nothing added to commit' in out:\n return False\n return True","def something_to_commit():\n\n # Procelain returns nothing if there's nothing to commit\n ret = subprocess.check_output([\"git\", \"status\", \"--porcelain\"])\n\n if (len(ret) > 0):\n return True\n\n return False","def changed(self):\n if self.exists():\n return self.current_content != self.content\n else:\n return True","def repo_has_uncommitted():\n buff = subprocess.check_output(['hg', 'status'])\n\n if len(buff):\n print('Dirty / uncommitted changes in repository!')\n return True\n\n return False","def _is_tracked(filename, metadata):\n current_local_sha = local_metadata.get(filename, None)\n current_remote_sha = metadata.get(filename, None)\n return current_local_sha is not None \\\n and current_remote_sha is not None \\\n and current_local_sha == current_remote_sha","def _can_checkout(wit_path) -> bool:\n\n current_id = _get_head(wit_path)\n changes_to_be_committed = _return_as_string(_get_changes_to_be_committed, wit_path, current_id)\n changes_not_staged_for_commit = _return_as_string(_get_changes_not_staged_for_commit, wit_path)\n if changes_to_be_committed + changes_not_staged_for_commit == '':\n return True\n logging.error(FileNotSavedError('Some files are not saved. Try \"status\" command to view them.'))\n return False","def has_changed(self) -> bool:\n # TODO: Add in change logic here\n state = None\n if state != self._file_state:\n self._changed_flag = True\n self._file_state = state\n return self._changed_flag","def need_update(self):\n self.logging.debug( \"need_update()\" )\n\n for name in self.tables:\n\n md5 = self.dbs_tables[name]['md5']\n test = get_md5(self.dbs_tables[name]['path'])\n\n self.logging.debug('(%s) table:%s md5:[old: %s new: %s]' % \\\n (self.db,name,md5,test) )\n\n if test != md5: return True\n\n return False","def has_unsaved_changes(self):\n return self._file_content != self.buffer.text","def validate_sha_github(sha):\n r = requests.head(github_changeset_url % sha)\n return r.status_code == 200","def is_old_sha(operator_tag):\n return operator_tag in SHA_DIGESTS_BEFORE_RESTRICTED_MODE_SUPPORT","def sha256_supplied(self):\n return self._sha256_supplied","def check_modified(self) -> bool:\n return bool(self._modified)","def has_hash(self, h):\n rsp = h.hashlist(self.path)\n if re.search(\"\\n[0-9a-f]+\\smd5\\s%s\" % self.path, rsp):\n rval = True\n else:\n rval = False\n return rval","def new_commits(repo, sha):\n from datetime import datetime\n\n dateformat = \"%a, %d %b %Y %H:%M:%S GMT\"\n release_commit = repo.get_commit(sha)\n since = datetime.strptime(release_commit.last_modified, dateformat)\n commits = repo.get_commits(since=since)\n if len(list(commits)) == 1:\n return False\n return reversed(list(commits)[:-1])","def git_has_object(project: Project, name: str) -> bool:\n ret = project.git(\"rev-parse\", \"--verify\", name, _ok_code=[0, 128])\n return ret.exit_code == 0","def isDirty(self):\n\t#@DEBUG christophe have to fix denoising optionnal issue prior to set isDirty() to True\n return False","def test_eq_true(self):\n self.assertTrue(self.instance == Commit(self.instance.sha))","def check_dirty(args):\n man = load_manifest()\n any_dirty = False\n for (name, project) in man.projects.iteritems():\n repo = GitRepo(workdir_for_project(project))\n any_dirty = check_dirty_repo(repo) or any_dirty\n return any_dirty","def is_update_success():\n file_success = os.getcwd() + \"\\\\last_success.txt\"\n if os.path.exists(file_success):\n return True\n else:\n return False","def dirty(self):\n return not self.consistent","def need_checksum_for_changes(self):\n # We don't need to run checksum for changes, if we don't want checksum\n # at all\n if not self.need_checksum():\n return False\n if self.is_full_table_dump:\n log.warning(\n \"We're adding new primary key to the table. Skip running \"\n \"checksum for changes, because that's inefficient\"\n )\n return False\n return True","def has_staged_changes(repo):\n return subprocess.call(['git', 'diff-index', '--cached', '--quiet', 'HEAD'],\n cwd=repo) != 0","def hasChanged(self):\r\n if self.is_updated:\r\n self.is_updated = False\r\n return True\r\n else:\r\n return False\r\n\r\n # if not self.hasBeenUpdatedOnce:\r\n # self.hasBeenUpdatedOnce = True\r\n # return True\r\n # else:\r\n # if BLENDER_MODE == 'BPY':\r\n # # for e in dir(self.obj): print(e)\r\n # # print(self.obj, self.obj.name, self.obj.is_updated, self.obj.is_updated_data)\r\n # # return self.obj.is_updated # DOESN't UPDATE A THING!\r\n # # return True\r\n # return self.is_updated\r\n\r\n # return False # no update in BGE mode\r","def is_git_dirty():\n dirty_status = local('git diff --quiet || echo \"*\"', capture=True)\n if dirty_status == '*':\n return True\n\n untracked_count = int(local('git status --porcelain 2>/dev/null| grep \"^??\" | wc -l', capture=True))\n if untracked_count > 0:\n return True\n\n return False","def check_file(self, path, approve_if_no_dbhash=False):\r\n if self.mod.filehash:\r\n h = create_filehash(path)\r\n return h == self.mod.filehash\r\n return approve_if_no_dbhash","def has_changed(self):\n return bool(self.changed_data)","def get_changed() -> bool:\n return g.ledger.changed()","def was_successful(self):\n return self._build_proto.status == common.SUCCESS","def _check_guts_eq(attr, old, new, last_build):\n if old != new:\n print \"building because %s changed\" % attr\n return True\n return False","def has_changed(self):\n timestamp = os.stat(self.filename).st_mtime\n if timestamp > self.last_timestamp:\n self.last_timestamp = timestamp\n return True\n return False","def changed(dirname, filename='.md5', args=None, glob=None):\n root = Path(dirname)\n if not root.exists():\n # if dirname doesn't exist it is changed (by definition)\n return True\n\n cachefile = root / filename\n current_digest = cachefile.open().read() if cachefile.exists() else \"\"\n \n _digest = digest(dirname, glob=glob)\n if args and args.verbose: # pragma: nocover\n print(\"md5:\", _digest)\n has_changed = current_digest != _digest\n\n if has_changed:\n with open(os.path.join(dirname, filename), 'w') as fp:\n fp.write(_digest)\n\n return has_changed","def check_dependency(self, repo, minhash=None):\n try:\n p = Project.objects.get(repo_url=repo)\n except Project.DoesNotExist:\n return False\n j = p.last_successful_job()\n\n if j:\n if minhash:\n if p.commit_in_history(minhash, j.commit):\n # We already have a successful job that is new enough\n return True\n else:\n return True\n\n return False","def check_md5checksum_in_cache_modified(file_hash: str, cache_path: Path, update: bool) -> bool:\n if cache_path.exists():\n old_md5_checksum_content = Path(cache_path).read_text()\n if old_md5_checksum_content.strip() != file_hash.strip():\n if update:\n save_md5_file(cache_path, file_hash)\n return True\n else:\n if update:\n save_md5_file(cache_path, file_hash)\n return True\n return False","def changed(self) -> bool:\n for chunk_location, chunk in self._chunk_cache.items():\n if chunk is None:\n # if the chunk is None and the saved record is not None, the chunk has changed.\n if chunk_location not in self._chunk_index:\n return True\n _, save_chunk_index = self._chunk_index[chunk_location]\n chunk_storage = self._chunk_history[chunk_location]\n if chunk_storage[save_chunk_index] is not None:\n return True\n elif chunk.changed:\n return True\n for chunk_index, save_chunk_index in self._chunk_index.values():\n if chunk_index != save_chunk_index:\n return True\n return False","def _is_hash_valid(self):\n downloaded_hash = sha1(self._downloaded_bytes).digest()\n return downloaded_hash == self.hash","def is_change(self) -> bool:\n return self._change","def check(self):\n if self.is_signed():\n data = self._document.read()\n hash_value = data[-self._append_size+1:-1]\n data = data[:-self._append_size]\n\n encrypted = self._encryptor.encrypt_cbc(data, self._init_vector)\n current_hash_value = encrypted[-16:]\n\n if current_hash_value != hash_value:\n print(\"Hash values did not matched!\")\n else:\n print(\"Hash values matched!\")\n else:\n print(\"The document is not signed!\")","def has_unsaved_changes():\n return False","def verify_checksum(self):\n return self.generate_header_checksum(omit_checksum=False) == 0","def canBeAccessed(self):\n \n try:\n self._client.log(self._repositoryUri)\n return True\n except ClientError, error:\n _logger.debug(error.args[0])\n for _, errorCode in error.args[1]:\n if errorCode == 160006: # We have no commit in the repository, but its ok.\n return True\n return False","def file_present(self,imagefile=None):\n import hashlib\n if self.filesize()==0:\n return False # empty files are never present\n if imagefile==None:\n imagefile=self.imagefile # use this one\n for hashname in ['md5','sha1']:\n oldhash = self.tag(hashname)\n if oldhash:\n newhash = hashlib.new(hashname,self.contents(imagefile=imagefile)).hexdigest()\n return oldhash==newhash\n raise ValueError,\"Cannot process file \"+self.filename()+\": no hash in \"+str(self)","def modified(self):\n\t\treturn self.last_modified > self.last_processed","def is_modified(self):\n return len(self.modified_fields) > 0","def is_dirty(self):\n return True in [n.is_dirty for n in self.nodes]","def dirty(self):\n return self._orig_line is not None","def modified(self):\r\n\t\treturn self.last_modified > self.last_processed","def valid(self):\n return self.hash.to_int('little') < self.target","def has_changed(self):\n return self.get_old_value() != self.get_current_value()","def has_been_modified(self):\n return self._has_been_modified","def verify_blob_checksum(self, blob):\n path = self.csum_to_path(blob)\n csum = path.checksum()\n return csum != blob","def valid(self):\n return (self.get(\"~#mtime\", 0) and\n self[\"~#mtime\"] == util.mtime(self[\"~filename\"]))","def is_changed(obj):\n revision_field = get_version_fieldname(obj)\n version = get_revision_of_object(obj)\n return not obj.__class__.objects.filter(**{obj._meta.pk.name: obj.pk,\n revision_field: version}).exists()","def path_touched(*paths, commit_range):\n return check_output([\n 'git', 'diff', '--name-only', commit_range, '--', *paths\n ]).decode('utf-8').strip() != ''","def has_unstaged_changes(repo):\n subprocess.check_call(['git', 'update-index', '-q', '--ignore-submodules',\n '--refresh'], cwd=repo)\n return subprocess.call(['git', 'diff-index', '--quiet', 'HEAD'],\n cwd=repo) != 0","def updated(self):\n return self._dict_hash != self.gen_model_hash(self.json(sort_keys=True))","def is_staging_clean() -> bool:\n c = cmd.run(\"git diff --no-ext-diff --cached --name-only\")\n return not bool(c.out)","def _is_always_unsatisfied(self):\n # If this is a github sha tarball, then it is always unsatisfied\n # because the url has a commit sha in it and not the version\n # number.\n url = self._req.url\n if url:\n filename = filename_from_url(url)\n if filename.endswith(ARCHIVE_EXTENSIONS):\n filename, ext = splitext(filename)\n if is_git_sha(filename):\n return True\n return False","def isDirty( self ):\n return self._dirty","def is_hash_locally_cached(self, ipfs_hash: str, ipfs_refs_local=None) -> bool:\n output = run([\"ipfs\", \"files\", \"stat\", \"--with-local\", \"--size\", f\"/ipfs/{ipfs_hash}\"])\n if \"(100.00%)\" in output:\n log(\"already fully cached\", \"green\")\n log(output)\n return True\n else:\n log(\"not fully cached\", \"red\")\n log(output)\n return False","def is_valid_git_sha1(hash):\r\n\r\n if len(hash) != 40:\r\n return False\r\n try:\r\n value = int(hash, 16)\r\n except ValueError:\r\n return False\r\n\r\n return True","def validate_checksum(self):\n return self.calculate_checksum() == self.checksum()","def verify(path, sha_path, verbose):\n if verbose:\n print(\"verifying\", path)\n with open(path, \"rb\") as source:\n found = hashlib.sha256(source.read()).hexdigest()\n with open(sha_path, \"r\") as sha256sum:\n expected = sha256sum.readline().split()[0]\n verified = found == expected\n if not verified:\n print(\"invalid checksum:\\n\"\n \" found: {}\\n\"\n \" expected: {}\".format(found, expected))\n return verified","def _check_guts_toc_mtime(attr, old, toc, last_build, pyc=0):\n for (nm, fnm, typ) in old:\n if mtime(fnm) > last_build:\n print \"building because %s changed\" % fnm\n return True\n elif pyc and mtime(fnm[:-1]) > last_build:\n print \"building because %s changed\" % fnm[:-1]\n return True\n return False","def isDirty(self):\n return self._dirty","def checkHash(song):\n\tsql = \"Select path, filename, hash from songs where hash = '\" + song.hash + \"';\"\n\tc, conn = connect()\n\tc.execute(sql)\n\tnotexists = True\n\tfor (path, filename, hash) in c:\n\t\tif hash == song.hash:\n\t\t\tnotexists = False\n\t\telse:\n\t\t\tnotexists = True\n\treturn notexists","def audit(self, data, proof_hashes):\n if self.root_hash == None:\n return False\n\n hash_ = self.sha256Sum(data)\n\n # A one element tree does not make much sense, but if one exists\n # we simply need to check if the files hash is the correct root\n if self.max_height == 0 and hash_ == self.root_hash:\n return True\n if self.max_height == 0 and hash_ != self.root_hash:\n return False\n\n proof_hashes_cp = copy.copy(proof_hashes)\n return self._audit(hash_, proof_hashes_cp)","def needs_rebuild(self) -> bool:\n old_hash = self._cache.get(\"config\", None)\n new_hash = utilities.hash_object_sha256(self._get_config_raw())\n self._cache[\"config\"] = new_hash\n\n if not old_hash:\n return False\n return old_hash != new_hash","def _can_update(self):\r\n if not self._is_persisted: return False\r\n pks = self._primary_keys.keys()\r\n return all([not self._values[k].changed for k in self._primary_keys])","def has_unsaved_changes(self):\n # TODO\n pass","def changelog_exists():\n\n output = subprocess.getoutput(['ls'])\n return 'changelog.md' in output.lower()","def is_dirty(self):\n return self.dirty","def is_dirty(self):\n return self.dirty","def original_modified(self):\n if self.modified > self.created:\n return True\n else:\n return False","def changelog_updated(target_branch):\n\n output = subprocess.getoutput(['git diff HEAD origin/{}'.format(target_branch)])\n return 'a/changelog.md b/changelog.md' in output.lower()","def __eq__(self, other):\n return self.sha == other.sha","def is_release_notes_changed(self):\n # there exists a difference between origin/master and current branch\n if self.master_diff:\n diff_releases = self.master_diff.split('##')\n unreleased_section = diff_releases[1]\n unreleased_section_lines = unreleased_section.split('\\n')\n\n adds_in_diff = 0\n removes_in_diff = 0\n\n for line in unreleased_section_lines:\n if line.startswith('+'):\n adds_in_diff += 1\n elif line.startswith('-') and not re.match(r'- *$', line):\n removes_in_diff += 1\n\n # means that at least one new line was added\n if adds_in_diff - removes_in_diff > 0:\n return True\n\n print_error(F'No new comment has been added in the release notes file: {self.release_notes_path}')\n return False","def check_for_major_changes(cabal: CabalFile) -> bool:\n old_ver = cabal.get_version()\n old_tag = None\n if f'v{old_ver}' in get_tags():\n old_tag = f'v{old_ver}'\n if f'{old_ver}' in get_tags():\n old_tag = f'{old_ver}'\n if old_tag is None:\n print(f\"Couldn't find tag {old_tag} for current version; skipping revision check.\\n\")\n return False\n\n cmd = ['git', 'diff', '--name-only', f'{old_tag}..HEAD']\n changed_files = [ l.strip()\n for l in check_output(cmd).decode('UTF-8').split('\\n')\n if len(l.strip()) > 0 ]\n non_cabals = [ f\n for f in changed_files\n if not f.endswith('.cabal') ]\n print(f\"{len(changed_files)} files have changed since {old_tag}:\\n \",\n ' \\n'.join(changed_files))\n\n if len(non_cabals) > 0:\n return False\n else:\n print(dedent(f'''\n It appears that the only changes between {old_tag} and now are in the\n cabal file. Perhaps you want to make a revision instead?\n\n y = make a revision\n n = do a full release anyways\n d = show me a diff\n '''))\n while True:\n resp = prompt_for_char('How to proceed?', options='ynd')\n if resp == 'd':\n cmd = ['git', 'diff', f'{old_tag}..HEAD']\n print(' '.join(cmd))\n check_call(cmd)\n elif resp == 'y':\n return True\n elif resp == 'n':\n return False","def changed(self) -> bool:\n return self._changed","def check_sha1(filename, sha1_hash):\n sha1 = hashlib.sha1()\n with open(filename, 'rb') as f:\n while True:\n data = f.read(1048576)\n if not data:\n break\n sha1.update(data)\n\n sha1_file = sha1.hexdigest()\n l = min(len(sha1_file), len(sha1_hash))\n return sha1.hexdigest()[0:l] == sha1_hash[0:l]","def has_checksum_file(self):\n return self.checksum_file_path.is_file()","def compute(self):\n\n commit_hashes = {item['hash'] for item in self.items}\n return len(commit_hashes)","def is_versioned(target):\n\n assert os.path.exists(target), \"%s does not exist!\" % target\n git_tree = get_git_tree(target)\n\n versioned = False\n if git_tree is not None:\n output = gitopen([\"status\", \"--ignored\", \"--porcelain\", target], git_tree)\n if not (output.startswith(b\"!!\") or output.startswith(b\"??\")):\n versioned = True\n\n return versioned","def is_outdated(self):\n\n if not self.is_done:\n return False\n elif not (self.input_files and self.output_files):\n return False\n\n return fileutils.modified_after(self.input_files, self.output_files)"],"string":"[\n \"def has_changes(self):\\n if self.repo_is_empty:\\n return True\\n\\n tree = self.repo.get(self.index.write_tree(self.repo))\\n diff = tree.diff_to_tree(self.repo.get(self.repo.head.target).tree)\\n return bool(diff)\",\n \"def index_is_dirty():\\n result, output = popen('git diff --cached', False, False)\\n return len(output) > 0\",\n \"def is_rev_dirty(ctx: \\\"PlanemoCliContext\\\", directory: str) -> bool:\\n return io.shell([\\\"git\\\", \\\"diff\\\", \\\"--quiet\\\"], cwd=directory) != 0\",\n \"def is_changed(self, include_md: bool = True) -> bool:\\n current = self.calculate_hash(include_md=include_md)\\n stored = self.hash if include_md else self.stub_hash\\n log.trace(f\\\"changed = {self.hash != current} | Stored: {stored} | Current: {current}\\\")\\n return stored != current\",\n \"def is_sha(self):\\n return self.name.startswith('SHA')\",\n \"def local_changes():\\n result, output = popen('git status', False, False)\\n try:\\n return not output[-1].startswith(\\\"nothing to commit\\\")\\n except IndexError:\\n return True\",\n \"def consistent(self):\\n return self.incore_digest == self.ondisk_digest\",\n \"def hash_comparison(self):\\n for result in self.cards:\\n if result.hash_status:\\n return True\\n return False\",\n \"def _is_commit_sha(commit):\\n return len(commit) == 40 and all([\\n ch.isdigit() or (ch >= \\\"a\\\" and ch <= \\\"f\\\")\\n for ch in commit.elems()\\n ])\",\n \"def dirty(self) -> bool:\\n return len(self.detect_changed_files()) != 0\",\n \"def check(self) -> bool:\\n return self.check_sum() == self.__md5_sum\",\n \"def hasChanged(self):\\n return ((self.mtime != getmtime(self.path)) or\\n (self.size != os.path.getsize(self.path)) )\",\n \"def isOpen(self):\\n return self.analyzed_digest != {}\",\n \"def needs_update(self, cache_key):\\r\\n return self._read_sha(cache_key) != cache_key.hash\",\n \"def is_git_sha(text):\\n # Handle both the full sha as well as the 7-character abbreviation\\n if len(text) in (40, 7):\\n try:\\n int(text, 16)\\n return True\\n except ValueError:\\n pass\\n return False\",\n \"def _check_md5(self):\\n\\n self.log.info('-' * 80)\\n self.log.info('Check md5 sum')\\n\\n self.log.info(self._ref_value)\\n self.log.info(self._output_file)\\n\\n code, out = cmd_exec(['md5sum', self._output_file], shell=False, log=self.log)\\n if code:\\n self.log.error(out)\\n return False\\n self.log.info(out)\\n\\n md5sum, _ = out.split(' ')\\n\\n self.log.info(f'reference md5: {self._ref_value}')\\n self.log.info(f'actual md5: {md5sum}')\\n\\n if self._ref_value != md5sum:\\n return False\\n\\n return True\",\n \"def has_changes(directory=None):\\n out = check_output('git status', shell=True, cwd=directory)\\n if 'nothing to commit (working directory clean)' in out:\\n return False\\n if 'nothing to commit, working directory clean' in out:\\n return False\\n if 'nothing to commit, working tree clean' in out:\\n return False\\n if 'nothing added to commit' in out:\\n return False\\n return True\",\n \"def something_to_commit():\\n\\n # Procelain returns nothing if there's nothing to commit\\n ret = subprocess.check_output([\\\"git\\\", \\\"status\\\", \\\"--porcelain\\\"])\\n\\n if (len(ret) > 0):\\n return True\\n\\n return False\",\n \"def changed(self):\\n if self.exists():\\n return self.current_content != self.content\\n else:\\n return True\",\n \"def repo_has_uncommitted():\\n buff = subprocess.check_output(['hg', 'status'])\\n\\n if len(buff):\\n print('Dirty / uncommitted changes in repository!')\\n return True\\n\\n return False\",\n \"def _is_tracked(filename, metadata):\\n current_local_sha = local_metadata.get(filename, None)\\n current_remote_sha = metadata.get(filename, None)\\n return current_local_sha is not None \\\\\\n and current_remote_sha is not None \\\\\\n and current_local_sha == current_remote_sha\",\n \"def _can_checkout(wit_path) -> bool:\\n\\n current_id = _get_head(wit_path)\\n changes_to_be_committed = _return_as_string(_get_changes_to_be_committed, wit_path, current_id)\\n changes_not_staged_for_commit = _return_as_string(_get_changes_not_staged_for_commit, wit_path)\\n if changes_to_be_committed + changes_not_staged_for_commit == '':\\n return True\\n logging.error(FileNotSavedError('Some files are not saved. Try \\\"status\\\" command to view them.'))\\n return False\",\n \"def has_changed(self) -> bool:\\n # TODO: Add in change logic here\\n state = None\\n if state != self._file_state:\\n self._changed_flag = True\\n self._file_state = state\\n return self._changed_flag\",\n \"def need_update(self):\\n self.logging.debug( \\\"need_update()\\\" )\\n\\n for name in self.tables:\\n\\n md5 = self.dbs_tables[name]['md5']\\n test = get_md5(self.dbs_tables[name]['path'])\\n\\n self.logging.debug('(%s) table:%s md5:[old: %s new: %s]' % \\\\\\n (self.db,name,md5,test) )\\n\\n if test != md5: return True\\n\\n return False\",\n \"def has_unsaved_changes(self):\\n return self._file_content != self.buffer.text\",\n \"def validate_sha_github(sha):\\n r = requests.head(github_changeset_url % sha)\\n return r.status_code == 200\",\n \"def is_old_sha(operator_tag):\\n return operator_tag in SHA_DIGESTS_BEFORE_RESTRICTED_MODE_SUPPORT\",\n \"def sha256_supplied(self):\\n return self._sha256_supplied\",\n \"def check_modified(self) -> bool:\\n return bool(self._modified)\",\n \"def has_hash(self, h):\\n rsp = h.hashlist(self.path)\\n if re.search(\\\"\\\\n[0-9a-f]+\\\\smd5\\\\s%s\\\" % self.path, rsp):\\n rval = True\\n else:\\n rval = False\\n return rval\",\n \"def new_commits(repo, sha):\\n from datetime import datetime\\n\\n dateformat = \\\"%a, %d %b %Y %H:%M:%S GMT\\\"\\n release_commit = repo.get_commit(sha)\\n since = datetime.strptime(release_commit.last_modified, dateformat)\\n commits = repo.get_commits(since=since)\\n if len(list(commits)) == 1:\\n return False\\n return reversed(list(commits)[:-1])\",\n \"def git_has_object(project: Project, name: str) -> bool:\\n ret = project.git(\\\"rev-parse\\\", \\\"--verify\\\", name, _ok_code=[0, 128])\\n return ret.exit_code == 0\",\n \"def isDirty(self):\\n\\t#@DEBUG christophe have to fix denoising optionnal issue prior to set isDirty() to True\\n return False\",\n \"def test_eq_true(self):\\n self.assertTrue(self.instance == Commit(self.instance.sha))\",\n \"def check_dirty(args):\\n man = load_manifest()\\n any_dirty = False\\n for (name, project) in man.projects.iteritems():\\n repo = GitRepo(workdir_for_project(project))\\n any_dirty = check_dirty_repo(repo) or any_dirty\\n return any_dirty\",\n \"def is_update_success():\\n file_success = os.getcwd() + \\\"\\\\\\\\last_success.txt\\\"\\n if os.path.exists(file_success):\\n return True\\n else:\\n return False\",\n \"def dirty(self):\\n return not self.consistent\",\n \"def need_checksum_for_changes(self):\\n # We don't need to run checksum for changes, if we don't want checksum\\n # at all\\n if not self.need_checksum():\\n return False\\n if self.is_full_table_dump:\\n log.warning(\\n \\\"We're adding new primary key to the table. Skip running \\\"\\n \\\"checksum for changes, because that's inefficient\\\"\\n )\\n return False\\n return True\",\n \"def has_staged_changes(repo):\\n return subprocess.call(['git', 'diff-index', '--cached', '--quiet', 'HEAD'],\\n cwd=repo) != 0\",\n \"def hasChanged(self):\\r\\n if self.is_updated:\\r\\n self.is_updated = False\\r\\n return True\\r\\n else:\\r\\n return False\\r\\n\\r\\n # if not self.hasBeenUpdatedOnce:\\r\\n # self.hasBeenUpdatedOnce = True\\r\\n # return True\\r\\n # else:\\r\\n # if BLENDER_MODE == 'BPY':\\r\\n # # for e in dir(self.obj): print(e)\\r\\n # # print(self.obj, self.obj.name, self.obj.is_updated, self.obj.is_updated_data)\\r\\n # # return self.obj.is_updated # DOESN't UPDATE A THING!\\r\\n # # return True\\r\\n # return self.is_updated\\r\\n\\r\\n # return False # no update in BGE mode\\r\",\n \"def is_git_dirty():\\n dirty_status = local('git diff --quiet || echo \\\"*\\\"', capture=True)\\n if dirty_status == '*':\\n return True\\n\\n untracked_count = int(local('git status --porcelain 2>/dev/null| grep \\\"^??\\\" | wc -l', capture=True))\\n if untracked_count > 0:\\n return True\\n\\n return False\",\n \"def check_file(self, path, approve_if_no_dbhash=False):\\r\\n if self.mod.filehash:\\r\\n h = create_filehash(path)\\r\\n return h == self.mod.filehash\\r\\n return approve_if_no_dbhash\",\n \"def has_changed(self):\\n return bool(self.changed_data)\",\n \"def get_changed() -> bool:\\n return g.ledger.changed()\",\n \"def was_successful(self):\\n return self._build_proto.status == common.SUCCESS\",\n \"def _check_guts_eq(attr, old, new, last_build):\\n if old != new:\\n print \\\"building because %s changed\\\" % attr\\n return True\\n return False\",\n \"def has_changed(self):\\n timestamp = os.stat(self.filename).st_mtime\\n if timestamp > self.last_timestamp:\\n self.last_timestamp = timestamp\\n return True\\n return False\",\n \"def changed(dirname, filename='.md5', args=None, glob=None):\\n root = Path(dirname)\\n if not root.exists():\\n # if dirname doesn't exist it is changed (by definition)\\n return True\\n\\n cachefile = root / filename\\n current_digest = cachefile.open().read() if cachefile.exists() else \\\"\\\"\\n \\n _digest = digest(dirname, glob=glob)\\n if args and args.verbose: # pragma: nocover\\n print(\\\"md5:\\\", _digest)\\n has_changed = current_digest != _digest\\n\\n if has_changed:\\n with open(os.path.join(dirname, filename), 'w') as fp:\\n fp.write(_digest)\\n\\n return has_changed\",\n \"def check_dependency(self, repo, minhash=None):\\n try:\\n p = Project.objects.get(repo_url=repo)\\n except Project.DoesNotExist:\\n return False\\n j = p.last_successful_job()\\n\\n if j:\\n if minhash:\\n if p.commit_in_history(minhash, j.commit):\\n # We already have a successful job that is new enough\\n return True\\n else:\\n return True\\n\\n return False\",\n \"def check_md5checksum_in_cache_modified(file_hash: str, cache_path: Path, update: bool) -> bool:\\n if cache_path.exists():\\n old_md5_checksum_content = Path(cache_path).read_text()\\n if old_md5_checksum_content.strip() != file_hash.strip():\\n if update:\\n save_md5_file(cache_path, file_hash)\\n return True\\n else:\\n if update:\\n save_md5_file(cache_path, file_hash)\\n return True\\n return False\",\n \"def changed(self) -> bool:\\n for chunk_location, chunk in self._chunk_cache.items():\\n if chunk is None:\\n # if the chunk is None and the saved record is not None, the chunk has changed.\\n if chunk_location not in self._chunk_index:\\n return True\\n _, save_chunk_index = self._chunk_index[chunk_location]\\n chunk_storage = self._chunk_history[chunk_location]\\n if chunk_storage[save_chunk_index] is not None:\\n return True\\n elif chunk.changed:\\n return True\\n for chunk_index, save_chunk_index in self._chunk_index.values():\\n if chunk_index != save_chunk_index:\\n return True\\n return False\",\n \"def _is_hash_valid(self):\\n downloaded_hash = sha1(self._downloaded_bytes).digest()\\n return downloaded_hash == self.hash\",\n \"def is_change(self) -> bool:\\n return self._change\",\n \"def check(self):\\n if self.is_signed():\\n data = self._document.read()\\n hash_value = data[-self._append_size+1:-1]\\n data = data[:-self._append_size]\\n\\n encrypted = self._encryptor.encrypt_cbc(data, self._init_vector)\\n current_hash_value = encrypted[-16:]\\n\\n if current_hash_value != hash_value:\\n print(\\\"Hash values did not matched!\\\")\\n else:\\n print(\\\"Hash values matched!\\\")\\n else:\\n print(\\\"The document is not signed!\\\")\",\n \"def has_unsaved_changes():\\n return False\",\n \"def verify_checksum(self):\\n return self.generate_header_checksum(omit_checksum=False) == 0\",\n \"def canBeAccessed(self):\\n \\n try:\\n self._client.log(self._repositoryUri)\\n return True\\n except ClientError, error:\\n _logger.debug(error.args[0])\\n for _, errorCode in error.args[1]:\\n if errorCode == 160006: # We have no commit in the repository, but its ok.\\n return True\\n return False\",\n \"def file_present(self,imagefile=None):\\n import hashlib\\n if self.filesize()==0:\\n return False # empty files are never present\\n if imagefile==None:\\n imagefile=self.imagefile # use this one\\n for hashname in ['md5','sha1']:\\n oldhash = self.tag(hashname)\\n if oldhash:\\n newhash = hashlib.new(hashname,self.contents(imagefile=imagefile)).hexdigest()\\n return oldhash==newhash\\n raise ValueError,\\\"Cannot process file \\\"+self.filename()+\\\": no hash in \\\"+str(self)\",\n \"def modified(self):\\n\\t\\treturn self.last_modified > self.last_processed\",\n \"def is_modified(self):\\n return len(self.modified_fields) > 0\",\n \"def is_dirty(self):\\n return True in [n.is_dirty for n in self.nodes]\",\n \"def dirty(self):\\n return self._orig_line is not None\",\n \"def modified(self):\\r\\n\\t\\treturn self.last_modified > self.last_processed\",\n \"def valid(self):\\n return self.hash.to_int('little') < self.target\",\n \"def has_changed(self):\\n return self.get_old_value() != self.get_current_value()\",\n \"def has_been_modified(self):\\n return self._has_been_modified\",\n \"def verify_blob_checksum(self, blob):\\n path = self.csum_to_path(blob)\\n csum = path.checksum()\\n return csum != blob\",\n \"def valid(self):\\n return (self.get(\\\"~#mtime\\\", 0) and\\n self[\\\"~#mtime\\\"] == util.mtime(self[\\\"~filename\\\"]))\",\n \"def is_changed(obj):\\n revision_field = get_version_fieldname(obj)\\n version = get_revision_of_object(obj)\\n return not obj.__class__.objects.filter(**{obj._meta.pk.name: obj.pk,\\n revision_field: version}).exists()\",\n \"def path_touched(*paths, commit_range):\\n return check_output([\\n 'git', 'diff', '--name-only', commit_range, '--', *paths\\n ]).decode('utf-8').strip() != ''\",\n \"def has_unstaged_changes(repo):\\n subprocess.check_call(['git', 'update-index', '-q', '--ignore-submodules',\\n '--refresh'], cwd=repo)\\n return subprocess.call(['git', 'diff-index', '--quiet', 'HEAD'],\\n cwd=repo) != 0\",\n \"def updated(self):\\n return self._dict_hash != self.gen_model_hash(self.json(sort_keys=True))\",\n \"def is_staging_clean() -> bool:\\n c = cmd.run(\\\"git diff --no-ext-diff --cached --name-only\\\")\\n return not bool(c.out)\",\n \"def _is_always_unsatisfied(self):\\n # If this is a github sha tarball, then it is always unsatisfied\\n # because the url has a commit sha in it and not the version\\n # number.\\n url = self._req.url\\n if url:\\n filename = filename_from_url(url)\\n if filename.endswith(ARCHIVE_EXTENSIONS):\\n filename, ext = splitext(filename)\\n if is_git_sha(filename):\\n return True\\n return False\",\n \"def isDirty( self ):\\n return self._dirty\",\n \"def is_hash_locally_cached(self, ipfs_hash: str, ipfs_refs_local=None) -> bool:\\n output = run([\\\"ipfs\\\", \\\"files\\\", \\\"stat\\\", \\\"--with-local\\\", \\\"--size\\\", f\\\"/ipfs/{ipfs_hash}\\\"])\\n if \\\"(100.00%)\\\" in output:\\n log(\\\"already fully cached\\\", \\\"green\\\")\\n log(output)\\n return True\\n else:\\n log(\\\"not fully cached\\\", \\\"red\\\")\\n log(output)\\n return False\",\n \"def is_valid_git_sha1(hash):\\r\\n\\r\\n if len(hash) != 40:\\r\\n return False\\r\\n try:\\r\\n value = int(hash, 16)\\r\\n except ValueError:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def validate_checksum(self):\\n return self.calculate_checksum() == self.checksum()\",\n \"def verify(path, sha_path, verbose):\\n if verbose:\\n print(\\\"verifying\\\", path)\\n with open(path, \\\"rb\\\") as source:\\n found = hashlib.sha256(source.read()).hexdigest()\\n with open(sha_path, \\\"r\\\") as sha256sum:\\n expected = sha256sum.readline().split()[0]\\n verified = found == expected\\n if not verified:\\n print(\\\"invalid checksum:\\\\n\\\"\\n \\\" found: {}\\\\n\\\"\\n \\\" expected: {}\\\".format(found, expected))\\n return verified\",\n \"def _check_guts_toc_mtime(attr, old, toc, last_build, pyc=0):\\n for (nm, fnm, typ) in old:\\n if mtime(fnm) > last_build:\\n print \\\"building because %s changed\\\" % fnm\\n return True\\n elif pyc and mtime(fnm[:-1]) > last_build:\\n print \\\"building because %s changed\\\" % fnm[:-1]\\n return True\\n return False\",\n \"def isDirty(self):\\n return self._dirty\",\n \"def checkHash(song):\\n\\tsql = \\\"Select path, filename, hash from songs where hash = '\\\" + song.hash + \\\"';\\\"\\n\\tc, conn = connect()\\n\\tc.execute(sql)\\n\\tnotexists = True\\n\\tfor (path, filename, hash) in c:\\n\\t\\tif hash == song.hash:\\n\\t\\t\\tnotexists = False\\n\\t\\telse:\\n\\t\\t\\tnotexists = True\\n\\treturn notexists\",\n \"def audit(self, data, proof_hashes):\\n if self.root_hash == None:\\n return False\\n\\n hash_ = self.sha256Sum(data)\\n\\n # A one element tree does not make much sense, but if one exists\\n # we simply need to check if the files hash is the correct root\\n if self.max_height == 0 and hash_ == self.root_hash:\\n return True\\n if self.max_height == 0 and hash_ != self.root_hash:\\n return False\\n\\n proof_hashes_cp = copy.copy(proof_hashes)\\n return self._audit(hash_, proof_hashes_cp)\",\n \"def needs_rebuild(self) -> bool:\\n old_hash = self._cache.get(\\\"config\\\", None)\\n new_hash = utilities.hash_object_sha256(self._get_config_raw())\\n self._cache[\\\"config\\\"] = new_hash\\n\\n if not old_hash:\\n return False\\n return old_hash != new_hash\",\n \"def _can_update(self):\\r\\n if not self._is_persisted: return False\\r\\n pks = self._primary_keys.keys()\\r\\n return all([not self._values[k].changed for k in self._primary_keys])\",\n \"def has_unsaved_changes(self):\\n # TODO\\n pass\",\n \"def changelog_exists():\\n\\n output = subprocess.getoutput(['ls'])\\n return 'changelog.md' in output.lower()\",\n \"def is_dirty(self):\\n return self.dirty\",\n \"def is_dirty(self):\\n return self.dirty\",\n \"def original_modified(self):\\n if self.modified > self.created:\\n return True\\n else:\\n return False\",\n \"def changelog_updated(target_branch):\\n\\n output = subprocess.getoutput(['git diff HEAD origin/{}'.format(target_branch)])\\n return 'a/changelog.md b/changelog.md' in output.lower()\",\n \"def __eq__(self, other):\\n return self.sha == other.sha\",\n \"def is_release_notes_changed(self):\\n # there exists a difference between origin/master and current branch\\n if self.master_diff:\\n diff_releases = self.master_diff.split('##')\\n unreleased_section = diff_releases[1]\\n unreleased_section_lines = unreleased_section.split('\\\\n')\\n\\n adds_in_diff = 0\\n removes_in_diff = 0\\n\\n for line in unreleased_section_lines:\\n if line.startswith('+'):\\n adds_in_diff += 1\\n elif line.startswith('-') and not re.match(r'- *$', line):\\n removes_in_diff += 1\\n\\n # means that at least one new line was added\\n if adds_in_diff - removes_in_diff > 0:\\n return True\\n\\n print_error(F'No new comment has been added in the release notes file: {self.release_notes_path}')\\n return False\",\n \"def check_for_major_changes(cabal: CabalFile) -> bool:\\n old_ver = cabal.get_version()\\n old_tag = None\\n if f'v{old_ver}' in get_tags():\\n old_tag = f'v{old_ver}'\\n if f'{old_ver}' in get_tags():\\n old_tag = f'{old_ver}'\\n if old_tag is None:\\n print(f\\\"Couldn't find tag {old_tag} for current version; skipping revision check.\\\\n\\\")\\n return False\\n\\n cmd = ['git', 'diff', '--name-only', f'{old_tag}..HEAD']\\n changed_files = [ l.strip()\\n for l in check_output(cmd).decode('UTF-8').split('\\\\n')\\n if len(l.strip()) > 0 ]\\n non_cabals = [ f\\n for f in changed_files\\n if not f.endswith('.cabal') ]\\n print(f\\\"{len(changed_files)} files have changed since {old_tag}:\\\\n \\\",\\n ' \\\\n'.join(changed_files))\\n\\n if len(non_cabals) > 0:\\n return False\\n else:\\n print(dedent(f'''\\n It appears that the only changes between {old_tag} and now are in the\\n cabal file. Perhaps you want to make a revision instead?\\n\\n y = make a revision\\n n = do a full release anyways\\n d = show me a diff\\n '''))\\n while True:\\n resp = prompt_for_char('How to proceed?', options='ynd')\\n if resp == 'd':\\n cmd = ['git', 'diff', f'{old_tag}..HEAD']\\n print(' '.join(cmd))\\n check_call(cmd)\\n elif resp == 'y':\\n return True\\n elif resp == 'n':\\n return False\",\n \"def changed(self) -> bool:\\n return self._changed\",\n \"def check_sha1(filename, sha1_hash):\\n sha1 = hashlib.sha1()\\n with open(filename, 'rb') as f:\\n while True:\\n data = f.read(1048576)\\n if not data:\\n break\\n sha1.update(data)\\n\\n sha1_file = sha1.hexdigest()\\n l = min(len(sha1_file), len(sha1_hash))\\n return sha1.hexdigest()[0:l] == sha1_hash[0:l]\",\n \"def has_checksum_file(self):\\n return self.checksum_file_path.is_file()\",\n \"def compute(self):\\n\\n commit_hashes = {item['hash'] for item in self.items}\\n return len(commit_hashes)\",\n \"def is_versioned(target):\\n\\n assert os.path.exists(target), \\\"%s does not exist!\\\" % target\\n git_tree = get_git_tree(target)\\n\\n versioned = False\\n if git_tree is not None:\\n output = gitopen([\\\"status\\\", \\\"--ignored\\\", \\\"--porcelain\\\", target], git_tree)\\n if not (output.startswith(b\\\"!!\\\") or output.startswith(b\\\"??\\\")):\\n versioned = True\\n\\n return versioned\",\n \"def is_outdated(self):\\n\\n if not self.is_done:\\n return False\\n elif not (self.input_files and self.output_files):\\n return False\\n\\n return fileutils.modified_after(self.input_files, self.output_files)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69775397","0.6945446","0.6825735","0.68252903","0.6719734","0.6671272","0.6610195","0.6565223","0.6532837","0.6526835","0.6508548","0.6499044","0.6385325","0.63748574","0.6319224","0.6314689","0.63038826","0.6292349","0.6275215","0.6274554","0.6246274","0.6239213","0.6232751","0.6206976","0.61877716","0.61662316","0.6165848","0.6158898","0.6149281","0.61447316","0.6067305","0.60669225","0.6061476","0.60506415","0.60495496","0.60482675","0.60463977","0.6036835","0.602954","0.60102654","0.6007176","0.60011506","0.5990005","0.5989979","0.5988558","0.59648436","0.5933169","0.592408","0.5917","0.59042466","0.58915263","0.58805335","0.58711874","0.5868117","0.5850648","0.5848601","0.5846991","0.584164","0.58265465","0.58247334","0.58238643","0.5819552","0.5816777","0.58072627","0.5803607","0.5794835","0.5786548","0.5781742","0.5771136","0.5755906","0.57509017","0.57324153","0.57263297","0.5723251","0.5719201","0.57173175","0.5717087","0.57079685","0.568946","0.5684553","0.5671596","0.5671145","0.56703895","0.5663467","0.56616503","0.5661144","0.5651745","0.5651206","0.5651206","0.56506807","0.56474257","0.56424624","0.563908","0.5638002","0.56207895","0.56181175","0.5617853","0.5606229","0.5606037","0.5603827"],"string":"[\n \"0.69775397\",\n \"0.6945446\",\n \"0.6825735\",\n \"0.68252903\",\n \"0.6719734\",\n \"0.6671272\",\n \"0.6610195\",\n \"0.6565223\",\n \"0.6532837\",\n \"0.6526835\",\n \"0.6508548\",\n \"0.6499044\",\n \"0.6385325\",\n \"0.63748574\",\n \"0.6319224\",\n \"0.6314689\",\n \"0.63038826\",\n \"0.6292349\",\n \"0.6275215\",\n \"0.6274554\",\n \"0.6246274\",\n \"0.6239213\",\n \"0.6232751\",\n \"0.6206976\",\n \"0.61877716\",\n \"0.61662316\",\n \"0.6165848\",\n \"0.6158898\",\n \"0.6149281\",\n \"0.61447316\",\n \"0.6067305\",\n \"0.60669225\",\n \"0.6061476\",\n \"0.60506415\",\n \"0.60495496\",\n \"0.60482675\",\n \"0.60463977\",\n \"0.6036835\",\n \"0.602954\",\n \"0.60102654\",\n \"0.6007176\",\n \"0.60011506\",\n \"0.5990005\",\n \"0.5989979\",\n \"0.5988558\",\n \"0.59648436\",\n \"0.5933169\",\n \"0.592408\",\n \"0.5917\",\n \"0.59042466\",\n \"0.58915263\",\n \"0.58805335\",\n \"0.58711874\",\n \"0.5868117\",\n \"0.5850648\",\n \"0.5848601\",\n \"0.5846991\",\n \"0.584164\",\n \"0.58265465\",\n \"0.58247334\",\n \"0.58238643\",\n \"0.5819552\",\n \"0.5816777\",\n \"0.58072627\",\n \"0.5803607\",\n \"0.5794835\",\n \"0.5786548\",\n \"0.5781742\",\n \"0.5771136\",\n \"0.5755906\",\n \"0.57509017\",\n \"0.57324153\",\n \"0.57263297\",\n \"0.5723251\",\n \"0.5719201\",\n \"0.57173175\",\n \"0.5717087\",\n \"0.57079685\",\n \"0.568946\",\n \"0.5684553\",\n \"0.5671596\",\n \"0.5671145\",\n \"0.56703895\",\n \"0.5663467\",\n \"0.56616503\",\n \"0.5661144\",\n \"0.5651745\",\n \"0.5651206\",\n \"0.5651206\",\n \"0.56506807\",\n \"0.56474257\",\n \"0.56424624\",\n \"0.563908\",\n \"0.5638002\",\n \"0.56207895\",\n \"0.56181175\",\n \"0.5617853\",\n \"0.5606229\",\n \"0.5606037\",\n \"0.5603827\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66552734"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":3185,"cells":{"query":{"kind":"string","value":"Read input from a text file"},"document":{"kind":"string","value":"def read_input():\n orbitDict = {}\n with open('day06_input.txt') as f:\n for line in f:\n planet, satellite = line.split(')')\n satellite = satellite.rstrip('\\n')\n\n if satellite in orbitDict:\n orbitDict[satellite].append(planet)\n else:\n orbitDict[satellite] = [planet]\n\n return orbitDict"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def read_input():\n return Path(__file__).with_name('input.txt').read_text().splitlines()","def read_txt(cls, input_file):\n return open(input_file, \"r\", encoding=\"utf-8\").readlines()","def read_txt(cls, input_file):\n return open(input_file, \"r\", encoding=\"utf-8\").readlines()","def read_data() -> str:\n with open('input.txt') as input_file:\n return input_file.read()","def simple_text_reader(text_file):\n with open(text_file, 'rt') as file:\n data = file.read()\n return data","def readInput(fileName):\n\n with open(fileName, 'r') as file:\n return file.read().splitlines()","def read_input_file(path: str):\n with open(path, \"r\") as f:\n return f.readlines()","def _read_input_file(self):\n pass","def read_filename(self, filename):\r\n self.text_lines = task3.read_text_file(filename)","def readInput(fileName):\n with open(fileName, 'r') as file:\n\n fileContent = file.read()\n\n return fileContent.split(\"\\n\")","def _read_txt(file_path):\n translation_pairs = []\n with file_path.open() as f:\n for line in f:\n translation_pairs.append(\n evaluation.TranslationPair(source=None, translation=line.strip())\n )\n return translation_pairs","def read_input(file_name='input.txt'):\n # always open relative to current file\n file_name = join(dirname(__file__), file_name)\n with open(file_name, 'r') as f_in:\n input_list = [line.strip()\n for line in f_in.readlines()\n if line.strip()]\n return map(int, input_list)","def readFromTextFile(self, file_name):\n with open(file_name, 'r') as file_obj:\n return file_obj.read()","def read(in_file):\n require_type(is_input(in_file), 'the parameter of read must be an input file')\n txt = in_file.readline().lower()\n while txt == '\\n':\n txt = in_file.readline().lower()\n return txt.strip() if txt else Symbol('#!eof')","def readInput(fileName):\r\n with open(fileName, 'r') as file:\r\n\r\n fileContent = []\r\n for line in file:\r\n fileContent.append(line.strip())\r\n\r\n return fileContent","def get_input():\n # return TEST_INPUT.split('\\n')\n with open(INPUT_FILE) as f:\n return f.readlines()","def read_from_file(self, filename: str) -> None:","def _read_data(self, txtfile):\n data_string = open(txtfile,'r').read()\n return data_string","def read_input_file(path):\n file_input = os.path.join(path, 'INPUT')\n f = open(file_input, 'r')\n lines = f.read().replace('\\n', ':')\n f.close()\n lines = ' '.join(lines.split()) #remove whitespace\n lines = re.split(':', lines.replace(': ', ':'))\n return lines","def read_text_file(file_name):\n target_file = open(file_name)\n lines = target_file.readlines()\n\n target_file.close()\n return lines","def read_input():\r\n tx = []\r\n with open(\"rail_input.txt\", \"r\") as file: \r\n data = file.readlines() \r\n for line in data:\r\n tx.append(line.strip())\r\n return tx","def read_input(input_path: str) -> str:\n with open(input_path, 'r') as input_file:\n input_data = input_file.read().strip()\n return input_data","def read_input(input_path: str) -> str:\n with open(input_path, 'r') as input_file:\n input_data = input_file.read().strip()\n return input_data","def load_txt(filename, **kwargs):\n with sys_open(filename, 'r', **kwargs) as f:\n return f.readlines()","def read_input(fname=\"day16.in\"):\n with open(fname) as f:\n return line2ints(f.read())","def open_and_read_file(file_path):\n text_data = open(file_path).read()\n # print text_data\n return text_data","def _read(self, in_file):\n self.string = in_file.readline().decode().strip()","def read_file(file_path):\n try:\n input_file = open(file_path)\n text_content = input_file.read()\n input_file.close()\n return text_content\n except IOError:\n print (\"Can not read from file\")","def load_input(self, path):\n f = codecs.open(path, 'r', 'utf-8')\n raw_text = f.read()\n return raw_text","def _read_file(self, input_file):\n with io.open(input_file, \"r\", encoding=\"UTF-8\") as file:\n examples = []\n for line in file:\n data = line.strip().split(\"_!_\")\n example = InputExample(\n guid=data[0], label=data[1], text_a=data[3])\n examples.append(example)\n\n return examples","def read_file(text_file):\n\n try:\n with open(text_file,\"r\") as handle:\n data = handle.read()\n return data\n except FileNotFoundError:\n return None","def read_text_file(str_name_file: str):\n content: str = ''\n with open(str_name_file, mode=\"r\", encoding='utf-8') as file:\n print(\"file being read: \" + str_name_file + \"\\n\")\n content = file.read()\n return content","def read(self, filename):\n pass","def read(self, filename):\n pass","def readFromFile(filename):\n raise NotImplementedError","def load_text_file(file_path: str):\n with open(file_path) as f:\n content = f.readlines()\n return content","def readTextFromFile(self, filename):\r\n f = open(filename)\r\n self.text = f.read()\r\n f.close()","def read_from_file(filename):\n\twith open(filename, 'r') as myfile:\n\t\ttext=myfile.read()\n\treturn text","def read_from_file(file_name):\n with open(file_name, \"rb\") as text_file:\n return text_file.read()","def input_data(self):\n return read_file(self.file_path)","def get_input():\n # return TEST_INPUT.strip().split('\\n\\n')\n with open(INPUT_FILE) as f:\n return f.read().strip().split('\\n\\n')","def readInput(in_file_name):\n in_file = open(in_file_name, 'r')\n positions = []\n samples = []\n M = []; P = [];\n MC = []; PC = [];\n while True:\n line = in_file.readline()\n if not line: break\n if line[0] == '#': continue #skip comment\n line = line.rstrip('\\n').split('\\t')\n \n #genomic positions and allele support in plasma samples\n positions.append(int(line[0]))\n samples.append(tuple(map(int, line[1:5])))\n \n #maternal and paternal alleles\n M.append(tuple(line[5:7]))\n MC.append(tuple(map(float, line[7:9])))\n \n P.append(tuple(line[9:11]))\n PC.append(tuple(map(float, line[11:13]))) \n \n in_file.close()\n return positions, samples, M, P, MC, PC","def read_input():\n splits = []\n with open('solutions/day5/input.txt') as f:\n for line in f:\n splits.append(line.strip('\\n'))\n return splits","def read1(cls):\n x_i = \"vas.txt\"\n with open(x_i, 'r')as txt_file:\n file = txt_file.readlines()\n return file","def read_input_file(filename=\"wires.txt\"):\n raw_wires = []\n with open(filename, 'r') as wirefile:\n raw_wires = wirefile.readlines()\n return raw_wires","def puzzle_input():\n with open('day13input.txt') as file:\n return file.read()","def read_text_file(file_name):\n \n file_data = {}\n \n with open(file_name) as fp:\n lines = fp.readlines()\n for line in lines:\n lineno = line.strip().split(':')[0].strip()\n #here we are checking whether a particluar line in the file contains a valid data [i.e line number and content]\n try:\n content = line.strip().split(':')[1].strip()\n file_data[lineno] = content\n except IndexError:\n pass\n \n return file_data","def read_txt(path):\n with open(path, \"r\") as f:\n return f.read().splitlines()","def read_txt(path):\n with open(path, \"r\") as f:\n return f.read().splitlines()","def read_txt_file(relative_path_to_txt_file: str):\n with open(file=relative_path_to_txt_file) as f:\n lines = f.read()\n return lines","def read_file():\n\n file = input(\"Input file: \")\n\n try:\n pfile = open(file)\n except: # Checks if the file can be opened\n print(\"ERROR: Could not open file \" + file)\n sys.exit()\n\n pfile = pfile.readlines()\n\n preorder = pfile[0].split()\n inorder = pfile[1].split()\n encode = pfile[2].strip()\n\n return preorder, inorder, encode","def read(self, inputfile):\n infile = open(inputfile, 'r')\n if (inputfile.lower().endswith('.po')):\n self.read_po(infile)\n elif (inputfile.lower().endswith('.json')):\n self.read_json(infile)\n elif (inputfile.lower().endswith('.xml')):\n self.read_properties(infile)\n infile.close()","def read_txt(path):\n \n with open(path, \"r\") as f:\n return f.read().splitlines()","def read(path):","def readText(self, filename, firstLine = 0, lastLine = None):\n \n assert filename.endswith('.txt')\n file = open(filename, 'r')\n self.samples = []\n\n li = 0\n while li < firstLine:\n if not file.readline():\n return\n li += 1\n\n while lastLine == None or li < lastLine:\n line = file.readline()\n if not line:\n return\n li += 1\n line = line.strip()\n if line:\n columns = line.split('|')\n if columns[1] == 'client-fps':\n self.samples.append(Sample(line, columns))","def load_input(self, file_name):\n with open(file_name, \"r\") as in_file:\n self.all_lines = [line.rstrip('\\n') for line in in_file]","def _read(cls, input_file, quotechar=None):\n with open(input_file, \"r\", encoding='utf-8') as f:\n lines = []\n for line in f:\n lines.append(line.strip())\n return lines","def handle_file(filename,operation = 'r'):\n with open(filename,operation) as f:\n data = f.readlines()\n return data","def read_text_file(text_file):\n try:\n with open(text_file, \"rb\") as f:\n text = tf.compat.as_str(f.read()) \n except Exception as e:\n print(\"Unable to open\", text_file, \":\", e)\n raise\n return text","def read_input_file(self):\n\n # Check if input file exists in current directory, if not kill process\n if not os.path.isfile('./visualise.inpt'):\n print('Cannot find input file \"visualise.inpt\" in current directory')\n sys.exit()\n\n # Read input file and analysis options and parameters\n print('Reading input file')\n with open('visualise.inpt','r') as f:\n f.readline()\n self.prefix = f.readline().split()[0]\n f.readline()\n f.readline()\n self.frame = int(f.readline().split()[0])\n f.readline()\n f.readline()\n self.vis_particles = int(f.readline().split()[0])\n self.vis_vortype = int(f.readline().split()[0])\n self.vis_cellcolour = int(f.readline().split()[0])\n self.vis_save = int(f.readline().split()[0])","def readInConfigFile( self, fileName ):\n self.console.info( \"Read input file\" )","def read_text_file(filename):\n try:\n file = open(filename, 'r')\n except:\n print('Cannot read file ' + filename + '. Please check the path', file=sys.stderr)\n sys.exit(1)\n output = []\n \n for line in file:\n line = line.strip().lower()\n output.append(line)\n return output","def load_from_txt(path):\n with open(path) as file:\n data = [line.rstrip() for line in file]\n return data","def _read(self, file_name):\n f = open(file_name)\n lines = f.readlines()\n begin = 0\n end = 0\n while end < len(lines):\n op = ''\n for l in lines[begin:]:\n end += 1\n op = l.split()[0]\n if op in operations:\n self.operations.append(op)\n break\n if op == '=push':\n nfa = Automaton(lines[begin:end - 1])\n self.aut_to_push.append(nfa)\n begin = end\n f.close()","def read(cls):\n x_i=\"vas.txt\"\n with open(x_i, 'r')as txt_file:\n file = txt_file.read()\n return file","def read_from_file(filename):\n with open(filename, \"r\") as f:\n f.readlines()","def read_file(filename):\r\n\r\n print(\"Reading TextFile \" + filename)\r\n text = []\r\n with open(filename, encoding=\"utf8\") as file:\r\n lines = file.readlines()\r\n for line in lines:\r\n line = line.strip()\r\n text.append(line)\r\n return text","def load_input(filepath: str) -> list:\n lines = []\n with open(filepath, \"r\", encoding=\"utf-8\") as file:\n for line in file.readlines():\n lines.append(line.strip())\n return lines","def read(self, filename):\n raise NotImplementedError","def read_txt(filename):\n file_object = open(filename, 'r')\n file_as_string = file_object.read()\n return create_word_list(file_as_string)","def file_reader(filePath):\n try:\n word_file = open(filePath, \"rt\")\n word_list = word_file.read().splitlines()\n word_file.close()\n return word_list\n except Exception:\n print(f\"An error has occured when reading the file.\")\n\n return","def myReadFile( path):\n f = open(path,'r')\n result = f.readlines()\n f.close\n return result","def readText(fileName):\n fileText = \"\"\n with open(fileName,\"r\") as fileObject:\n fileText = fileObject.read()\n \n return fileText","def read_in_file(self):\n try: # we are opening the file, this could fail..\n for line in open(self.question_file, 'r').readlines(): # Open the file and read in all the lines and put them in an array\n if line == '\\n': # if the line is simply equal to \"\\n\"\n continue # \"continue\" means \"don't continue execution, go back to the top of the loop\n else: # the line simply isn't \"\\n\" so let's append it.\n self.question_data.append(line.rstrip()) # append the line to the self.question_data array, strip the \\n off\n except OSError as err: # Let's capture the exception catch\n print(\"Problem opening question file: %s\" % self.question_file)\n fatal(\"System Error {0}\".format(err), -1) # let's print FATAL and the actual exception catch msg and exit -1","def read_inpfile(self, filename):\n return wntr.network.io.read_inpfile(filename, append=self)","def read_file(path):\n try:\n with open(path, 'r') as text_file:\n return \"\".join(text_file.readlines()).strip()\n except IOError:\n exit(\"Error: file '%s' is not readable!\" % path)","def get_input(file_name, separator='\\n'):\n with open(file_name) as input_file:\n input_data = input_file.read().split(separator)\n return input_data","def parse_txt_file(txtfile):\n array = np.genfromtxt(txtfile)\n return array","def read_input(fname=\"day11.in\"):\n with open(fname) as f:\n return [int(v.strip()) for v in next(f).split(\",\")]","def open_and_read_file(file_path):\n\n contents = open(file_path).read()\n words = contents.split()\n return words","def read_data(cls, input_file,quotechar = None):\n if 'pkl' in str(input_file):\n lines = load_pickle(input_file)\n else:\n lines = input_file\n return lines","def read_file(path):\n # Mystery arguments:\n strictness = False\n # Read the string:\n return _iterate_bibtexsource(_bibtex.open_file(path, strictness))","def from_text_file(cls, filename):\n raise NotImplementedError()","def open_and_read_file(file_path):\n\n text_file = open(file_path)\n full_text = text_file.read()\n\n return full_text","def read_data(cls, input_file, quotechar=None):\r\n if 'pkl' in str(input_file):\r\n lines = load_pickle(input_file)\r\n else:\r\n lines = input_file\r\n return lines","def read_text(filename):\n with open(filename, 'r') as f:\n com = f.readline()[0]\n wavelength, flux = np.loadtxt(filename, unpack=True,\n usecols=(0, 1), comments=com)\n return wavelength, flux","def read_file(self, file_name: str):\n file_text = []\n with open(file_name, encoding='utf-8', errors='ignore') as file:\n for line in file:\n line = line.strip()\n file_text.append(line)\n return file_text","def read_input(fname=\"day05.in\"):\n with open(fname) as f:\n return [int(v.strip()) for v in next(f).split(\",\")]","def load_file(file):\r\n\r\n try:\r\n with open(Path(file), \"r\", encoding=\"utf-8\", newline=\"\") as f:\r\n txt_file = f.read()\r\n except:\r\n sys.exit(\"IO_Tools: ERROR: \"+str(file)+\" not found!\")\r\n \r\n lines = txt_file.split(\"\\n\")\r\n\r\n return lines","def read_input(infile):\n #Some utility functions to read in particular types of input\n def read_int():\n return int(infile.readline().strip())\n def read_ints():\n return np.array(infile.readline().split(), dtype=int)\n def read_bigints(): #For ints that won't fit directly in an int32 array\n line = infile.readline().split()\n return np.array(map(lambda x: int(x), line))\n def read_float():\n return float(infile.readline().strip())\n def read_floats():\n return np.array(infile.readline().split(), dtype=float)\n def read_string():\n return infile.readline().strip()\n def read_strings():\n return np.array(infile.readline().split(), dtype=object) #N.B. general dtype\n \n N = read_int()\n cars = read_strings()\n assert N == len(cars)\n \n return cars","def read_file(input_file):\n with open(input_file, \"r\", encoding=\"utf-8-sig\") as f:\n sentences = f.read().splitlines()\n return sentences","def readfile(file):\n with open(file, 'r') as f:\n data = f.read().splitlines()\n return data","def txt_file_reader(path):\n return open(path, encoding=cfg.ENCODING)","def read():\n # TODO","def get_inputs_from_file(filename=\"\"):\n import json\n\n with open(filename) as input_text:\n json_obj = json.load(input_text)\n return json_obj","def read_text_file(file_name, ncol = 0):\n\t\n\tfrom string import split\n\tinf = file(file_name, \"r\")\n\tline = inf.readline()\n\tdata = []\n\twhile len(line) > 0:\n\t\tif ncol == -1:\n\t\t\tvdata = split(line)\n\t\t\tif data == []:\n\t\t\t\tfor i in xrange(len(vdata)):\n\t\t\t\t\tdata.append([float(vdata[i])])\n\t\t\telse:\n\t\t\t\tfor i in xrange(len(vdata)):\n\t\t\t\t\tdata[i].append(float(vdata[i]))\t\t\t\n\t\telse:\n\t\t\tvdata = float(split(line)[ncol])\n\t\t\tdata.append(vdata)\n\t\tline = inf.readline()\n\treturn data","def read_file(self):\n Tk().withdraw() # we don't want a full GUI, so keep the root window from appearing\n self.filename = askopenfilename(title='Select Hospital Text File') # show an \"Open\" dialog box and return the path to the selected file","def read_file(path_to_file):\n 8","def read_text(text_path):\n if not os.path.exists(text_path):\n raise IOError('File does not exist: %s' % text_path)\n return open(text_path).read()","def read_text(filename):\n\n if '.txt' not in filename:\n raise ValueError('Input file must be a .txt file!')\n\n if filename[:4] == \"http\": # website\n website = urlopen(filename)\n # slicing to get rid of project gutenberg preamble/license\n txt = website.read().decode('UTF-8').lower()[800:-19500]\n else: # text file\n f = open(filename)\n txt = f.read().lower()\n\n # strip punctuation. Have switched hyphens to a capital letter and back so that they do not get removed.\n translator = txt.maketrans('--', ' ')\n txt = txt.translate(translator)\n translator = txt.maketrans('-', 'A')\n txt = txt.translate(translator)\n translator = txt.maketrans(\"\\n\\r\\t\", ' '*3)\n txt = txt.translate(translator)\n translator = txt.maketrans('', '', string.punctuation + \"'`’‘”“\")\n txt = txt.translate(translator)\n translator = txt.maketrans('A', '-')\n txt = txt.translate(translator).split(' ')\n\n return [s for s in txt if s !='']","def read_file(file_path):\n file_contents = None\n with open(file_path) as f_desc:\n file_contents = f_desc.read()\n if not file_contents:\n raise CLIError('Could not read {}'.format(file_path))\n return file_contents"],"string":"[\n \"def read_input():\\n return Path(__file__).with_name('input.txt').read_text().splitlines()\",\n \"def read_txt(cls, input_file):\\n return open(input_file, \\\"r\\\", encoding=\\\"utf-8\\\").readlines()\",\n \"def read_txt(cls, input_file):\\n return open(input_file, \\\"r\\\", encoding=\\\"utf-8\\\").readlines()\",\n \"def read_data() -> str:\\n with open('input.txt') as input_file:\\n return input_file.read()\",\n \"def simple_text_reader(text_file):\\n with open(text_file, 'rt') as file:\\n data = file.read()\\n return data\",\n \"def readInput(fileName):\\n\\n with open(fileName, 'r') as file:\\n return file.read().splitlines()\",\n \"def read_input_file(path: str):\\n with open(path, \\\"r\\\") as f:\\n return f.readlines()\",\n \"def _read_input_file(self):\\n pass\",\n \"def read_filename(self, filename):\\r\\n self.text_lines = task3.read_text_file(filename)\",\n \"def readInput(fileName):\\n with open(fileName, 'r') as file:\\n\\n fileContent = file.read()\\n\\n return fileContent.split(\\\"\\\\n\\\")\",\n \"def _read_txt(file_path):\\n translation_pairs = []\\n with file_path.open() as f:\\n for line in f:\\n translation_pairs.append(\\n evaluation.TranslationPair(source=None, translation=line.strip())\\n )\\n return translation_pairs\",\n \"def read_input(file_name='input.txt'):\\n # always open relative to current file\\n file_name = join(dirname(__file__), file_name)\\n with open(file_name, 'r') as f_in:\\n input_list = [line.strip()\\n for line in f_in.readlines()\\n if line.strip()]\\n return map(int, input_list)\",\n \"def readFromTextFile(self, file_name):\\n with open(file_name, 'r') as file_obj:\\n return file_obj.read()\",\n \"def read(in_file):\\n require_type(is_input(in_file), 'the parameter of read must be an input file')\\n txt = in_file.readline().lower()\\n while txt == '\\\\n':\\n txt = in_file.readline().lower()\\n return txt.strip() if txt else Symbol('#!eof')\",\n \"def readInput(fileName):\\r\\n with open(fileName, 'r') as file:\\r\\n\\r\\n fileContent = []\\r\\n for line in file:\\r\\n fileContent.append(line.strip())\\r\\n\\r\\n return fileContent\",\n \"def get_input():\\n # return TEST_INPUT.split('\\\\n')\\n with open(INPUT_FILE) as f:\\n return f.readlines()\",\n \"def read_from_file(self, filename: str) -> None:\",\n \"def _read_data(self, txtfile):\\n data_string = open(txtfile,'r').read()\\n return data_string\",\n \"def read_input_file(path):\\n file_input = os.path.join(path, 'INPUT')\\n f = open(file_input, 'r')\\n lines = f.read().replace('\\\\n', ':')\\n f.close()\\n lines = ' '.join(lines.split()) #remove whitespace\\n lines = re.split(':', lines.replace(': ', ':'))\\n return lines\",\n \"def read_text_file(file_name):\\n target_file = open(file_name)\\n lines = target_file.readlines()\\n\\n target_file.close()\\n return lines\",\n \"def read_input():\\r\\n tx = []\\r\\n with open(\\\"rail_input.txt\\\", \\\"r\\\") as file: \\r\\n data = file.readlines() \\r\\n for line in data:\\r\\n tx.append(line.strip())\\r\\n return tx\",\n \"def read_input(input_path: str) -> str:\\n with open(input_path, 'r') as input_file:\\n input_data = input_file.read().strip()\\n return input_data\",\n \"def read_input(input_path: str) -> str:\\n with open(input_path, 'r') as input_file:\\n input_data = input_file.read().strip()\\n return input_data\",\n \"def load_txt(filename, **kwargs):\\n with sys_open(filename, 'r', **kwargs) as f:\\n return f.readlines()\",\n \"def read_input(fname=\\\"day16.in\\\"):\\n with open(fname) as f:\\n return line2ints(f.read())\",\n \"def open_and_read_file(file_path):\\n text_data = open(file_path).read()\\n # print text_data\\n return text_data\",\n \"def _read(self, in_file):\\n self.string = in_file.readline().decode().strip()\",\n \"def read_file(file_path):\\n try:\\n input_file = open(file_path)\\n text_content = input_file.read()\\n input_file.close()\\n return text_content\\n except IOError:\\n print (\\\"Can not read from file\\\")\",\n \"def load_input(self, path):\\n f = codecs.open(path, 'r', 'utf-8')\\n raw_text = f.read()\\n return raw_text\",\n \"def _read_file(self, input_file):\\n with io.open(input_file, \\\"r\\\", encoding=\\\"UTF-8\\\") as file:\\n examples = []\\n for line in file:\\n data = line.strip().split(\\\"_!_\\\")\\n example = InputExample(\\n guid=data[0], label=data[1], text_a=data[3])\\n examples.append(example)\\n\\n return examples\",\n \"def read_file(text_file):\\n\\n try:\\n with open(text_file,\\\"r\\\") as handle:\\n data = handle.read()\\n return data\\n except FileNotFoundError:\\n return None\",\n \"def read_text_file(str_name_file: str):\\n content: str = ''\\n with open(str_name_file, mode=\\\"r\\\", encoding='utf-8') as file:\\n print(\\\"file being read: \\\" + str_name_file + \\\"\\\\n\\\")\\n content = file.read()\\n return content\",\n \"def read(self, filename):\\n pass\",\n \"def read(self, filename):\\n pass\",\n \"def readFromFile(filename):\\n raise NotImplementedError\",\n \"def load_text_file(file_path: str):\\n with open(file_path) as f:\\n content = f.readlines()\\n return content\",\n \"def readTextFromFile(self, filename):\\r\\n f = open(filename)\\r\\n self.text = f.read()\\r\\n f.close()\",\n \"def read_from_file(filename):\\n\\twith open(filename, 'r') as myfile:\\n\\t\\ttext=myfile.read()\\n\\treturn text\",\n \"def read_from_file(file_name):\\n with open(file_name, \\\"rb\\\") as text_file:\\n return text_file.read()\",\n \"def input_data(self):\\n return read_file(self.file_path)\",\n \"def get_input():\\n # return TEST_INPUT.strip().split('\\\\n\\\\n')\\n with open(INPUT_FILE) as f:\\n return f.read().strip().split('\\\\n\\\\n')\",\n \"def readInput(in_file_name):\\n in_file = open(in_file_name, 'r')\\n positions = []\\n samples = []\\n M = []; P = [];\\n MC = []; PC = [];\\n while True:\\n line = in_file.readline()\\n if not line: break\\n if line[0] == '#': continue #skip comment\\n line = line.rstrip('\\\\n').split('\\\\t')\\n \\n #genomic positions and allele support in plasma samples\\n positions.append(int(line[0]))\\n samples.append(tuple(map(int, line[1:5])))\\n \\n #maternal and paternal alleles\\n M.append(tuple(line[5:7]))\\n MC.append(tuple(map(float, line[7:9])))\\n \\n P.append(tuple(line[9:11]))\\n PC.append(tuple(map(float, line[11:13]))) \\n \\n in_file.close()\\n return positions, samples, M, P, MC, PC\",\n \"def read_input():\\n splits = []\\n with open('solutions/day5/input.txt') as f:\\n for line in f:\\n splits.append(line.strip('\\\\n'))\\n return splits\",\n \"def read1(cls):\\n x_i = \\\"vas.txt\\\"\\n with open(x_i, 'r')as txt_file:\\n file = txt_file.readlines()\\n return file\",\n \"def read_input_file(filename=\\\"wires.txt\\\"):\\n raw_wires = []\\n with open(filename, 'r') as wirefile:\\n raw_wires = wirefile.readlines()\\n return raw_wires\",\n \"def puzzle_input():\\n with open('day13input.txt') as file:\\n return file.read()\",\n \"def read_text_file(file_name):\\n \\n file_data = {}\\n \\n with open(file_name) as fp:\\n lines = fp.readlines()\\n for line in lines:\\n lineno = line.strip().split(':')[0].strip()\\n #here we are checking whether a particluar line in the file contains a valid data [i.e line number and content]\\n try:\\n content = line.strip().split(':')[1].strip()\\n file_data[lineno] = content\\n except IndexError:\\n pass\\n \\n return file_data\",\n \"def read_txt(path):\\n with open(path, \\\"r\\\") as f:\\n return f.read().splitlines()\",\n \"def read_txt(path):\\n with open(path, \\\"r\\\") as f:\\n return f.read().splitlines()\",\n \"def read_txt_file(relative_path_to_txt_file: str):\\n with open(file=relative_path_to_txt_file) as f:\\n lines = f.read()\\n return lines\",\n \"def read_file():\\n\\n file = input(\\\"Input file: \\\")\\n\\n try:\\n pfile = open(file)\\n except: # Checks if the file can be opened\\n print(\\\"ERROR: Could not open file \\\" + file)\\n sys.exit()\\n\\n pfile = pfile.readlines()\\n\\n preorder = pfile[0].split()\\n inorder = pfile[1].split()\\n encode = pfile[2].strip()\\n\\n return preorder, inorder, encode\",\n \"def read(self, inputfile):\\n infile = open(inputfile, 'r')\\n if (inputfile.lower().endswith('.po')):\\n self.read_po(infile)\\n elif (inputfile.lower().endswith('.json')):\\n self.read_json(infile)\\n elif (inputfile.lower().endswith('.xml')):\\n self.read_properties(infile)\\n infile.close()\",\n \"def read_txt(path):\\n \\n with open(path, \\\"r\\\") as f:\\n return f.read().splitlines()\",\n \"def read(path):\",\n \"def readText(self, filename, firstLine = 0, lastLine = None):\\n \\n assert filename.endswith('.txt')\\n file = open(filename, 'r')\\n self.samples = []\\n\\n li = 0\\n while li < firstLine:\\n if not file.readline():\\n return\\n li += 1\\n\\n while lastLine == None or li < lastLine:\\n line = file.readline()\\n if not line:\\n return\\n li += 1\\n line = line.strip()\\n if line:\\n columns = line.split('|')\\n if columns[1] == 'client-fps':\\n self.samples.append(Sample(line, columns))\",\n \"def load_input(self, file_name):\\n with open(file_name, \\\"r\\\") as in_file:\\n self.all_lines = [line.rstrip('\\\\n') for line in in_file]\",\n \"def _read(cls, input_file, quotechar=None):\\n with open(input_file, \\\"r\\\", encoding='utf-8') as f:\\n lines = []\\n for line in f:\\n lines.append(line.strip())\\n return lines\",\n \"def handle_file(filename,operation = 'r'):\\n with open(filename,operation) as f:\\n data = f.readlines()\\n return data\",\n \"def read_text_file(text_file):\\n try:\\n with open(text_file, \\\"rb\\\") as f:\\n text = tf.compat.as_str(f.read()) \\n except Exception as e:\\n print(\\\"Unable to open\\\", text_file, \\\":\\\", e)\\n raise\\n return text\",\n \"def read_input_file(self):\\n\\n # Check if input file exists in current directory, if not kill process\\n if not os.path.isfile('./visualise.inpt'):\\n print('Cannot find input file \\\"visualise.inpt\\\" in current directory')\\n sys.exit()\\n\\n # Read input file and analysis options and parameters\\n print('Reading input file')\\n with open('visualise.inpt','r') as f:\\n f.readline()\\n self.prefix = f.readline().split()[0]\\n f.readline()\\n f.readline()\\n self.frame = int(f.readline().split()[0])\\n f.readline()\\n f.readline()\\n self.vis_particles = int(f.readline().split()[0])\\n self.vis_vortype = int(f.readline().split()[0])\\n self.vis_cellcolour = int(f.readline().split()[0])\\n self.vis_save = int(f.readline().split()[0])\",\n \"def readInConfigFile( self, fileName ):\\n self.console.info( \\\"Read input file\\\" )\",\n \"def read_text_file(filename):\\n try:\\n file = open(filename, 'r')\\n except:\\n print('Cannot read file ' + filename + '. Please check the path', file=sys.stderr)\\n sys.exit(1)\\n output = []\\n \\n for line in file:\\n line = line.strip().lower()\\n output.append(line)\\n return output\",\n \"def load_from_txt(path):\\n with open(path) as file:\\n data = [line.rstrip() for line in file]\\n return data\",\n \"def _read(self, file_name):\\n f = open(file_name)\\n lines = f.readlines()\\n begin = 0\\n end = 0\\n while end < len(lines):\\n op = ''\\n for l in lines[begin:]:\\n end += 1\\n op = l.split()[0]\\n if op in operations:\\n self.operations.append(op)\\n break\\n if op == '=push':\\n nfa = Automaton(lines[begin:end - 1])\\n self.aut_to_push.append(nfa)\\n begin = end\\n f.close()\",\n \"def read(cls):\\n x_i=\\\"vas.txt\\\"\\n with open(x_i, 'r')as txt_file:\\n file = txt_file.read()\\n return file\",\n \"def read_from_file(filename):\\n with open(filename, \\\"r\\\") as f:\\n f.readlines()\",\n \"def read_file(filename):\\r\\n\\r\\n print(\\\"Reading TextFile \\\" + filename)\\r\\n text = []\\r\\n with open(filename, encoding=\\\"utf8\\\") as file:\\r\\n lines = file.readlines()\\r\\n for line in lines:\\r\\n line = line.strip()\\r\\n text.append(line)\\r\\n return text\",\n \"def load_input(filepath: str) -> list:\\n lines = []\\n with open(filepath, \\\"r\\\", encoding=\\\"utf-8\\\") as file:\\n for line in file.readlines():\\n lines.append(line.strip())\\n return lines\",\n \"def read(self, filename):\\n raise NotImplementedError\",\n \"def read_txt(filename):\\n file_object = open(filename, 'r')\\n file_as_string = file_object.read()\\n return create_word_list(file_as_string)\",\n \"def file_reader(filePath):\\n try:\\n word_file = open(filePath, \\\"rt\\\")\\n word_list = word_file.read().splitlines()\\n word_file.close()\\n return word_list\\n except Exception:\\n print(f\\\"An error has occured when reading the file.\\\")\\n\\n return\",\n \"def myReadFile( path):\\n f = open(path,'r')\\n result = f.readlines()\\n f.close\\n return result\",\n \"def readText(fileName):\\n fileText = \\\"\\\"\\n with open(fileName,\\\"r\\\") as fileObject:\\n fileText = fileObject.read()\\n \\n return fileText\",\n \"def read_in_file(self):\\n try: # we are opening the file, this could fail..\\n for line in open(self.question_file, 'r').readlines(): # Open the file and read in all the lines and put them in an array\\n if line == '\\\\n': # if the line is simply equal to \\\"\\\\n\\\"\\n continue # \\\"continue\\\" means \\\"don't continue execution, go back to the top of the loop\\n else: # the line simply isn't \\\"\\\\n\\\" so let's append it.\\n self.question_data.append(line.rstrip()) # append the line to the self.question_data array, strip the \\\\n off\\n except OSError as err: # Let's capture the exception catch\\n print(\\\"Problem opening question file: %s\\\" % self.question_file)\\n fatal(\\\"System Error {0}\\\".format(err), -1) # let's print FATAL and the actual exception catch msg and exit -1\",\n \"def read_inpfile(self, filename):\\n return wntr.network.io.read_inpfile(filename, append=self)\",\n \"def read_file(path):\\n try:\\n with open(path, 'r') as text_file:\\n return \\\"\\\".join(text_file.readlines()).strip()\\n except IOError:\\n exit(\\\"Error: file '%s' is not readable!\\\" % path)\",\n \"def get_input(file_name, separator='\\\\n'):\\n with open(file_name) as input_file:\\n input_data = input_file.read().split(separator)\\n return input_data\",\n \"def parse_txt_file(txtfile):\\n array = np.genfromtxt(txtfile)\\n return array\",\n \"def read_input(fname=\\\"day11.in\\\"):\\n with open(fname) as f:\\n return [int(v.strip()) for v in next(f).split(\\\",\\\")]\",\n \"def open_and_read_file(file_path):\\n\\n contents = open(file_path).read()\\n words = contents.split()\\n return words\",\n \"def read_data(cls, input_file,quotechar = None):\\n if 'pkl' in str(input_file):\\n lines = load_pickle(input_file)\\n else:\\n lines = input_file\\n return lines\",\n \"def read_file(path):\\n # Mystery arguments:\\n strictness = False\\n # Read the string:\\n return _iterate_bibtexsource(_bibtex.open_file(path, strictness))\",\n \"def from_text_file(cls, filename):\\n raise NotImplementedError()\",\n \"def open_and_read_file(file_path):\\n\\n text_file = open(file_path)\\n full_text = text_file.read()\\n\\n return full_text\",\n \"def read_data(cls, input_file, quotechar=None):\\r\\n if 'pkl' in str(input_file):\\r\\n lines = load_pickle(input_file)\\r\\n else:\\r\\n lines = input_file\\r\\n return lines\",\n \"def read_text(filename):\\n with open(filename, 'r') as f:\\n com = f.readline()[0]\\n wavelength, flux = np.loadtxt(filename, unpack=True,\\n usecols=(0, 1), comments=com)\\n return wavelength, flux\",\n \"def read_file(self, file_name: str):\\n file_text = []\\n with open(file_name, encoding='utf-8', errors='ignore') as file:\\n for line in file:\\n line = line.strip()\\n file_text.append(line)\\n return file_text\",\n \"def read_input(fname=\\\"day05.in\\\"):\\n with open(fname) as f:\\n return [int(v.strip()) for v in next(f).split(\\\",\\\")]\",\n \"def load_file(file):\\r\\n\\r\\n try:\\r\\n with open(Path(file), \\\"r\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\") as f:\\r\\n txt_file = f.read()\\r\\n except:\\r\\n sys.exit(\\\"IO_Tools: ERROR: \\\"+str(file)+\\\" not found!\\\")\\r\\n \\r\\n lines = txt_file.split(\\\"\\\\n\\\")\\r\\n\\r\\n return lines\",\n \"def read_input(infile):\\n #Some utility functions to read in particular types of input\\n def read_int():\\n return int(infile.readline().strip())\\n def read_ints():\\n return np.array(infile.readline().split(), dtype=int)\\n def read_bigints(): #For ints that won't fit directly in an int32 array\\n line = infile.readline().split()\\n return np.array(map(lambda x: int(x), line))\\n def read_float():\\n return float(infile.readline().strip())\\n def read_floats():\\n return np.array(infile.readline().split(), dtype=float)\\n def read_string():\\n return infile.readline().strip()\\n def read_strings():\\n return np.array(infile.readline().split(), dtype=object) #N.B. general dtype\\n \\n N = read_int()\\n cars = read_strings()\\n assert N == len(cars)\\n \\n return cars\",\n \"def read_file(input_file):\\n with open(input_file, \\\"r\\\", encoding=\\\"utf-8-sig\\\") as f:\\n sentences = f.read().splitlines()\\n return sentences\",\n \"def readfile(file):\\n with open(file, 'r') as f:\\n data = f.read().splitlines()\\n return data\",\n \"def txt_file_reader(path):\\n return open(path, encoding=cfg.ENCODING)\",\n \"def read():\\n # TODO\",\n \"def get_inputs_from_file(filename=\\\"\\\"):\\n import json\\n\\n with open(filename) as input_text:\\n json_obj = json.load(input_text)\\n return json_obj\",\n \"def read_text_file(file_name, ncol = 0):\\n\\t\\n\\tfrom string import split\\n\\tinf = file(file_name, \\\"r\\\")\\n\\tline = inf.readline()\\n\\tdata = []\\n\\twhile len(line) > 0:\\n\\t\\tif ncol == -1:\\n\\t\\t\\tvdata = split(line)\\n\\t\\t\\tif data == []:\\n\\t\\t\\t\\tfor i in xrange(len(vdata)):\\n\\t\\t\\t\\t\\tdata.append([float(vdata[i])])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfor i in xrange(len(vdata)):\\n\\t\\t\\t\\t\\tdata[i].append(float(vdata[i]))\\t\\t\\t\\n\\t\\telse:\\n\\t\\t\\tvdata = float(split(line)[ncol])\\n\\t\\t\\tdata.append(vdata)\\n\\t\\tline = inf.readline()\\n\\treturn data\",\n \"def read_file(self):\\n Tk().withdraw() # we don't want a full GUI, so keep the root window from appearing\\n self.filename = askopenfilename(title='Select Hospital Text File') # show an \\\"Open\\\" dialog box and return the path to the selected file\",\n \"def read_file(path_to_file):\\n 8\",\n \"def read_text(text_path):\\n if not os.path.exists(text_path):\\n raise IOError('File does not exist: %s' % text_path)\\n return open(text_path).read()\",\n \"def read_text(filename):\\n\\n if '.txt' not in filename:\\n raise ValueError('Input file must be a .txt file!')\\n\\n if filename[:4] == \\\"http\\\": # website\\n website = urlopen(filename)\\n # slicing to get rid of project gutenberg preamble/license\\n txt = website.read().decode('UTF-8').lower()[800:-19500]\\n else: # text file\\n f = open(filename)\\n txt = f.read().lower()\\n\\n # strip punctuation. Have switched hyphens to a capital letter and back so that they do not get removed.\\n translator = txt.maketrans('--', ' ')\\n txt = txt.translate(translator)\\n translator = txt.maketrans('-', 'A')\\n txt = txt.translate(translator)\\n translator = txt.maketrans(\\\"\\\\n\\\\r\\\\t\\\", ' '*3)\\n txt = txt.translate(translator)\\n translator = txt.maketrans('', '', string.punctuation + \\\"'`’‘”“\\\")\\n txt = txt.translate(translator)\\n translator = txt.maketrans('A', '-')\\n txt = txt.translate(translator).split(' ')\\n\\n return [s for s in txt if s !='']\",\n \"def read_file(file_path):\\n file_contents = None\\n with open(file_path) as f_desc:\\n file_contents = f_desc.read()\\n if not file_contents:\\n raise CLIError('Could not read {}'.format(file_path))\\n return file_contents\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80333656","0.73937935","0.73937935","0.7325028","0.7260986","0.72499967","0.72369945","0.712606","0.7094524","0.70686525","0.69390434","0.6938965","0.6922924","0.68762004","0.68759114","0.68530405","0.68422097","0.67936075","0.67765266","0.6772103","0.6754905","0.67473525","0.67473525","0.6726431","0.6720038","0.6665915","0.66620106","0.66521084","0.6638513","0.6625374","0.6603505","0.6567475","0.65621763","0.65621763","0.6559847","0.65585935","0.6540416","0.65377474","0.6517126","0.6514316","0.65054554","0.6501766","0.6500878","0.64915836","0.6469703","0.6468749","0.6453031","0.6434721","0.6434721","0.6423808","0.6420907","0.64068407","0.64022654","0.6398541","0.63894796","0.6384324","0.6378887","0.6370953","0.6369451","0.63534635","0.63433725","0.63342446","0.63307214","0.63300097","0.6329512","0.63293827","0.63251585","0.6320512","0.6314581","0.63145083","0.63139737","0.630884","0.6306951","0.6306539","0.62916994","0.62882733","0.6285201","0.6279981","0.62745184","0.6273009","0.62706697","0.6270334","0.6261505","0.6248187","0.6246732","0.6216517","0.6214354","0.62142855","0.6203794","0.6176728","0.6174175","0.61735046","0.6172751","0.6170998","0.61656326","0.6157625","0.6154607","0.6139352","0.61362845","0.61310744","0.6129817"],"string":"[\n \"0.80333656\",\n \"0.73937935\",\n \"0.73937935\",\n \"0.7325028\",\n \"0.7260986\",\n \"0.72499967\",\n \"0.72369945\",\n \"0.712606\",\n \"0.7094524\",\n \"0.70686525\",\n \"0.69390434\",\n \"0.6938965\",\n \"0.6922924\",\n \"0.68762004\",\n \"0.68759114\",\n \"0.68530405\",\n \"0.68422097\",\n \"0.67936075\",\n \"0.67765266\",\n \"0.6772103\",\n \"0.6754905\",\n \"0.67473525\",\n \"0.67473525\",\n \"0.6726431\",\n \"0.6720038\",\n \"0.6665915\",\n \"0.66620106\",\n \"0.66521084\",\n \"0.6638513\",\n \"0.6625374\",\n \"0.6603505\",\n \"0.6567475\",\n \"0.65621763\",\n \"0.65621763\",\n \"0.6559847\",\n \"0.65585935\",\n \"0.6540416\",\n \"0.65377474\",\n \"0.6517126\",\n \"0.6514316\",\n \"0.65054554\",\n \"0.6501766\",\n \"0.6500878\",\n \"0.64915836\",\n \"0.6469703\",\n \"0.6468749\",\n \"0.6453031\",\n \"0.6434721\",\n \"0.6434721\",\n \"0.6423808\",\n \"0.6420907\",\n \"0.64068407\",\n \"0.64022654\",\n \"0.6398541\",\n \"0.63894796\",\n \"0.6384324\",\n \"0.6378887\",\n \"0.6370953\",\n \"0.6369451\",\n \"0.63534635\",\n \"0.63433725\",\n \"0.63342446\",\n \"0.63307214\",\n \"0.63300097\",\n \"0.6329512\",\n \"0.63293827\",\n \"0.63251585\",\n \"0.6320512\",\n \"0.6314581\",\n \"0.63145083\",\n \"0.63139737\",\n \"0.630884\",\n \"0.6306951\",\n \"0.6306539\",\n \"0.62916994\",\n \"0.62882733\",\n \"0.6285201\",\n \"0.6279981\",\n \"0.62745184\",\n \"0.6273009\",\n \"0.62706697\",\n \"0.6270334\",\n \"0.6261505\",\n \"0.6248187\",\n \"0.6246732\",\n \"0.6216517\",\n \"0.6214354\",\n \"0.62142855\",\n \"0.6203794\",\n \"0.6176728\",\n \"0.6174175\",\n \"0.61735046\",\n \"0.6172751\",\n \"0.6170998\",\n \"0.61656326\",\n \"0.6157625\",\n \"0.6154607\",\n \"0.6139352\",\n \"0.61362845\",\n \"0.61310744\",\n \"0.6129817\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3186,"cells":{"query":{"kind":"string","value":"Counts the number of orbitating planets"},"document":{"kind":"string","value":"def num_of_orbits(orbitDict):\n\n total_orbits = len(orbitDict.keys())\n total_orbits += independent_orbits(orbitDict)\n\n return total_orbits"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def orbit_count(self) -> int:\n if self.orbit:\n return 1 + self.orbit.orbit_count()\n return 0","def orbit_count(objects: Dict[str, ObjectMass]) -> int:\n total = 0\n\n for mass in objects.values():\n total += mass.orbit_count()\n\n return total","def count():","def count_balls(self, **kwargs):\n return 0","def test_number_of_surface_objects(self):\n for O in self.mod.objts.itervalues():\n no_of_surfaces = 0\n for C in O.conts.itervalues():\n if C.surf != 0:\n no_of_surfaces += 1\n self.assertEqual(O.surfsize, no_of_surfaces)","def countComponents26(cube):\n n,l = labelComponents26(cube);\n return n;","def countPanelTrajectoryExpressions(self):\n nbr = 0\n for e in self.children:\n nbr += e.countPanelTrajectoryExpressions()\n return nbr","def get_neighbor_live_count(cart):\n count = 0\n for i in range(6):\n cart2 = (cart[0] + dxv[i],cart[1] + dyv[i],cart[2] + dzv[i])\n if check_cart(cart2) and voxel_data[cart_to_loc(cart2)] == 1:\n count += 1\n return count","def count_pegs(self):\r\n count = 0\r\n\r\n for i in range(0, len(self.matrix)):\r\n for j in range(0, len(self.matrix[i])):\r\n if self.matrix[i][j] == \"1\":\r\n count += 1\r\n\r\n return count","def drawCountPlotPlanets(df):\n plt.style.use('dark_background')\n fig, ax = plt.subplots(figsize=(15,8))\n sns.countplot(x=df.amount_of_planets, data=df, palette='Reds_d')\n plt.show()","def obstacle_count(self):\n #scan area in front of robot\n self.scan()\n #Figure ot how many obstacles there were\n see_an_object = False\n count = 0","def nbr_tours(self):\n nbr_tours = 0\n for i in range(3):\n for j in range(3):\n if self.grille[i][j] != 0:\n nbr_tours += 1\n return nbr_tours","def num_atoms(self):\n return self.h5['{}/{}'.format(SETTINGS, N_ATOMS)][()]","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def airport_count(airport_data, state_abbr):\n \n counter = 0\n \n for dat in airport_data:\n \n if dat[3] == state_abbr:\n \n counter += 1\n \n return counter","def num_wet(self):\n return np.sum(self.array == 5)","def count_all_atoms(self):\n n = 0\n for model in self.iter_models():\n n += model.count_all_atoms()\n return n","def count_atoms(self):\n n = 0\n for chain in self.iter_chains():\n n += chain.count_atoms()\n return n","def count_atoms(self):\n n = 0\n for chain in self.iter_chains():\n n += chain.count_atoms()\n return n","def total_number_of_animals(self):\n animals = self.animal()\n print 'Total number of animals on island: {:4}'.format(\n animals[\"Herbivores\"] + animals[\"Carnivores\"])","def get_num_plants(self) -> int:\r\n\r\n return len(self.plants)","def number_of_carnivores_island(self):\n return np.sum(self.carnivores_on_island)","def number_of_atoms(formula):\n pass\n # ======== YOUR CODE HERE ========","def count(self, syms = None ):\n if syms == None:\n syms = self.alpha.getSymbols()\n for sym in syms:\n idx = self.alpha.getIndex( sym )\n self.cnt[idx] += 1.0\n self.tot += 1","def getNumTiles(self):\n return len(list(product(list(range(self.width+1))[1:], list(range(self.height+1))[1:])))","def obstacle_count(self):\n self.wide_scan()\n found_something = False\n counter = 0\n for distance in self.scan:\n if distance and distance < 200 and not found_something:\n found_something = True\n counter += 1\n print(\"Object # %d found, I think\" % counter)\n if distance and distance > 200 and found_something:\n found_something = False\n print(\"\\n----I SEE %d OBJECTS----\\n\" % counter)","def count_all_atoms(self):\n n = 0\n for atm in self.atom_order_list:\n if isinstance(atm, Atom):\n n += 1\n else:\n n += len(atm)\n return n","def Points_Counting(self):\n return len(self.__traectory_list)","def get_num_markets(add):\r\n name=get_zipcode_names(add)\r\n engine = get_sql_engine()\r\n number_markets = text(\r\n \"\"\"\r\n SELECT COUNT(\"NAME\") AS num_markets\r\n FROM farmers_markets\r\n WHERE \"ZIP\" = :name\r\n \"\"\"\r\n )\r\n resp = engine.execute(number_markets, name=name).fetchone()\r\n return resp[\"num_markets\"]","def n_tracers(self):\n # Extract parameters\n pzs = self.params[0]\n return len(pzs)","def n_tracers(self):\n # Extract parameters\n pzs = self.params[0]\n return len(pzs)","def getNumberOfTraces(self) -> int:\n\n if not self.debug:\n self.myFieldFox.write(\"CALC:PAR:COUN?\")\n ret = self.myFieldFox.read()\n else:\n ret = 4\n return ret","def count(self, volume):\n\n countResult = 0\n\n for x in range(volume.shape[0]):\n for y in range(volume.shape[1]):\n for z in range(volume.shape[2]):\n if self.isMember(volume[x,y,z]):\n countResult += 1\n\n return countResult","def n_rays(self):\n try: \n return self._n_rays\n except AttributeError:\n self._n_rays = 0\n for r in self.rays(): self._n_rays += 1\n return self._n_rays","def num_trajs(self):\n return len(list(self.run_traj_idx_tuples()))","def countPanelTrajectoryExpressions(self):\n return 1 + self.child.countPanelTrajectoryExpressions()","def number_of_atoms(self):\n if self._number_of_atoms is None:\n if self.mol is not None:\n self._number_of_atoms = len(self.mol.atoms)\n elif not self.is_ts:\n self._number_of_atoms = len(self.get_xyz().splitlines())\n return self._number_of_atoms","def count_timepoints(sc, session, files):\n tuples = zip(range(len(files)), files)\n files_sc = sc.parallelize(tuples)\n\n def count_planes(kv):\n index, path2 = kv\n try:\n from ScanImageTiffReader import ScanImageTiffReader\n img = ScanImageTiffReader(path2).data()\n except Exception:\n import tifffile\n img = tifffile.imread(path2)\n return img.shape[0]\n\n data2 = files_sc.map(count_planes).collect()\n frame_numbers = np.array(data2)\n vol_numbers = frame_numbers / len(session.fieldMask)\n return vol_numbers.astype(int)","def get_num_streets(market):\r\n return len(market)","def count() -> int:\n pass","def voxel_count(self):\n return self.cols * self.rows * self.sections","def main():\n row, col, island = make_matrix()\n print(count_island(row, col, island))","def obstacle_count(self):\n for x in range(6):\n # do a scan of the area in front of the robot\n self.scan()\n\n \n see_an_object = False\n count = 0 \n # Do a scan and count the amount of objects in the way\n for angle in self.scan_data:\n dist = self.scan_data[angle]\n if dist < self.SAFE_DISTANCE and not see_an_object: \n see_an_object = True\n count += 1\n print(\"~~~ I SEE SOMETHING!! ~~~\")\n elif dist > self.SAFE_DISTANCE and see_an_object:\n see_an_object = False\n print(\"I guess the object ended\") \n print(\"ANGLE: %d | DIST: %d\" % (angle, dist))\n self.turn_by_deg(90)\n print(\"\\nI saw %d objects\" % count)","def getnumbarablocktriplets(self): # 3\n res,resargs = self.__obj.getnumbarablocktriplets()\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n _num_return_value = resargs\n return _num_return_value","def number_of_herbivores_island(self):\n return np.sum(self.herbivores_on_island)","def get_orbit_hops(self) -> Dict[str, int]:\n total = 0\n orbit_hops = {}\n\n orbit = self.orbit\n\n while orbit:\n orbit_hops[orbit.name] = total\n orbit = orbit.orbit\n total += 1\n\n return orbit_hops","def count(self):\n return self.vcount","def count(self):\n return len(self._components)","def count_waters(self):\n n = 0\n for frag in self.iter_waters():\n n += 1\n return n","def _count_parties(data_set): #DEMOCRATS, THEN REPUBLICANS\r\n reps = 0\r\n dems = 0\r\n for data_point in data_set:\r\n if data_point.dat_party == \"R\": reps+=1\r\n if data_point.dat_party == \"D\": dems+=1\r\n\r\n return (dems, reps)","def get_number_of_atoms_to_optimize(self):\n v = self.c.get(simulation_cell=True)\n return len(v.data.stoichiometry)","def count_support(projection):\n\tprev_id = -1\n\tsize = 0\n\tfor p in projection:\n\t\tif prev_id != p.id:\n\t\t\tprev_id = p.id\n\t\t\tsize += 1\n\treturn size","def numel(self):\n return self.t.size","def nb_triples(self) -> int:\n return 0","def nAtoms(self, species = None, element = None):\n try:\n m = self.elementIndex(element)\n k = self.speciesIndex(species)\n na = _cantera.phase_natoms(self._phase_id, k, m)\n #if na < 0: return 0\n return na\n except CanteraError:\n return 0","def atom_count(self):\n return len(self.repeated_elements())","def getNumTiles(self):\n return (self.width) * (self.height)","def count_all_atoms(self):\n n = 0\n for chain in self.iter_chains():\n n += chain.count_all_atoms()\n return n","def count(self):\n # TODO not implemented yet\n return 0","def getNumTiles(self):\n\t\treturn self.numTiles","def number_of_constituents(bc_class):\n num_trn = 0\n cn = bc_class.constituent_properties\n if cn.salinity:\n num_trn += 1\n if cn.temperature:\n num_trn += 1\n if cn.vorticity:\n num_trn += 1\n if not cn.general_constituents.empty:\n num_trn += len(cn.general_constituents.index)\n if not cn.sand.empty:\n num_trn += len(cn.sand.index)\n if not cn.clay.empty:\n num_trn += len(cn.clay.index)\n return num_trn","def all_valid(self, tower) -> int:\r\n count = 0\r\n for layer in range(1, len(tower.tower)):\r\n for index in range(1, 4):\r\n if self.is_valid(layer, index, tower):\r\n count += 1\r\n \r\n return count","def count(self):\n\n raise NotImplementedError","def N(self):\n return len(self.cavity_grid.cavities) + 1","def gal_count(clusters):\n sum = 0\n for x in clusters:\n sum += x.ngal\n return sum","def num_injectors(self):\n injectors = self.info_wells.groupby('well_type').get_group('inj')\n return injectors['well'].nunique()","def get_number_of_ions(exp_builder, phase, system_id):\n # Read in output pdb file to read ionic strength.\n if phase == 'complex' or phase == 'solvent1':\n phase_id = 0\n else:\n phase_id = 1\n system_filepath = exp_builder._db.get_system_files_paths(system_id)[phase_id].position_path\n system_filepath = os.path.splitext(system_filepath)[0] + '.pdb'\n system_traj = mdtraj.load(system_filepath)\n\n # Count number of waters and ions.\n n_waters = 0\n n_pos_ions = 0\n n_neg_ions = 0\n for res in system_traj.topology.residues:\n if res.is_water:\n n_waters += 1\n elif '+' in res.name:\n n_pos_ions += 1\n elif '-' in res.name:\n n_neg_ions += 1\n\n # Verify that number of ions roughly models the expected ionic strength.\n try:\n solvent_id = exp_builder._db.systems[system_id]['solvent']\n except KeyError:\n solvent_id = exp_builder._db.systems[system_id][phase] # solvent1 or solvent2\n ionic_strength = exp_builder._db.solvents[solvent_id]['ionic_strength']\n n_ionic_strength_ions = int(np.round(n_waters * ionic_strength / (55.41*unit.molar)))\n\n return n_pos_ions, n_neg_ions, n_ionic_strength_ions","def numAtoms(self):\n return self.nAtoms","def get_numberOfProjections(self):\n self._nproj = len(self._projIndices)\n return self._nproj","def count(self, trace):\n return len(trace)","def natoms(self):\n return len(self.atoms)","def noOfPlayers(self):\n\t\tnumber = 0\n\t\tfor n in range(6):\n\t\t\tif self.playerList[n] != None:\n\t\t\t\tnumber = number + 1\n\t\treturn number","def ir_count(self) -> int:\n return int(self.graph_tuple_stats.ir_count or 0)","def count_rotation_numels(model):\n total = 0\n for m in model.modules():\n if isinstance(m, (ConvLayerRotation, LinearLayerRotation)):\n total += m.rotation_matrix.numel()\n return total","def __len__(self):\n i = 0\n for S in self.states():\n i += 1\n return i","def getNrStations(self):\n return len(self.stationData)","def get_num_petals(self):\n return self._num_petals","def get_vehicle_count(self):\n return len(self.vehicles)","def num_ellipsoids(self):\n return self._shape_count(_sff.ellipsoid)","def get_number_of_ocean_levels(description):\n\n if description == \"none\":\n return \"0\"\n elif re.search(\"levels\", description):\n match = re.search(\"(?P<nlo>\\d+)\\s?(levels|vertical levels)\", description)\n return match.groupdict()[\"nlo\"]\n else:\n return \"60\"","def numAtoms(self):\n\n\t\tnatoms = 0\n\t\tfor chain in self.chain:\n\t\t\tfor residue in chain.residue:\n\t\t\t\tnatoms += residue.numAtoms()\n\n\t\treturn natoms","def total_num_atoms(self):\n return self.GetNumberOfAtoms()","def getNumTiles(self):\n return self.height * self.width","def __len__(self):\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios","def __len__(self):\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios","def __len__(self):\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios","def __len__(self):\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios","def get_num_of_baskets(self):\n return self.num_of_baskets","def _count_explores(self) -> int:\n explore_count = 0\n for model in self.project.models:\n explore_count += len(model.explores)\n return explore_count","def n_pos(self):\n running_total = 0\n for i in range(self.prob.num):\n if self.alphas[i] > 1e-5 > self.prob.C - self.deltas[i] and self.prob.Y[i] == 1:\n running_total += 1\n return running_total if running_total > 0 else 1","def n_pos(self):\n running_total = 0\n for i in range(self.prob.num):\n if self.alphas[i] > 1e-5 > self.prob.C - self.deltas[i] and self.prob.Y[i] == 1:\n running_total += 1\n return running_total if running_total > 0 else 1","def lives_counter(self):\n count = 15\n for row in self.board:\n for column in row:\n if column == HITSHIP:\n count -= 1\n self.lives = count\n return self.lives","def GetNumberOfVariables(self):\n\n # nvar = 0\n # for i in self.variables_order:\n # # DO NOT COUNT VARIABLES THAT GET CONDENSED OUT\n # if i!=0:\n # if mesh.element_type == \"tri\":\n # nvar += (i+1)*(i+2) // 2\n # elif mesh.element_type == \"tet\":\n # nvar += (i+1)*(i+2)*(i+3) // 6\n # elif mesh.element_type == \"quad\":\n # nvar += (i+1)**2\n # elif mesh.element_type == \"hex\":\n # nvar += (i+1)**3\n\n # nvar = sum(self.variables_order)\n if self.nvar == None:\n self.nvar = self.ndim\n return self.nvar","def num_animals(self):\n return self._num_herbs + self._num_carns","def getNumTiles(self):\n return self.w * self.h","def n_atoms(self) -> int:\n return 0 if self.atoms is None else len(self.atoms)","def num_nbrs_torus(A, r, j, c, k):\n\tnum = 0\n\tr = r - 1 # to account for off by one errors\n\tc = c - 1\n\tif j == 0:\n\t\tif k == 0:\n\t\t\t# top left corner edge case\n\t\t\tif A[r, c] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, c] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, c] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\t\tif A[r, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\tif k > 0 and k < c:\n\t\t\t# top row minus corners edge cases\n\t\t\tif A[r, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\t\tif A[r, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\n\t\tif k == c:\n\t\t\t# top right corner edge case\n\t\t\tif A[r, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\t\tif A[r, 0] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, 0] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, 0] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\n\t\tif A[j+1,k] == ALIVE:\n\t\t\tnum += 1\n\t\tif A[r, k] == ALIVE:\n\t\t\tnum += 1\n\n\tif j > 0 and j < r:\n\t\tif k == 0:\n\t\t\t# left side minus corners edge cases\n\t\t\tif A[j-1, c] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, c] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, c] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\t\tif A[j-1, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\tif k > 0 and k < c:\n\t\t\t# center\n\t\t\tif A[j-1, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\t\tif A[j-1, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\n\t\tif k == c:\n\t\t\t# right side minus corners edge cases\n\t\t\tif A[j-1, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\t\tif A[j-1, 0] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, 0] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j+1, 0] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\n\t\tif A[j+1,k] == ALIVE:\n\t\t\tnum += 1\n\t\tif A[j-1, k] == ALIVE:\n\t\t\tnum += 1\n\n\n\tif j == r:\n\t\tif k == 0:\n\t\t\t# bottom left corner edge cases\n\t\t\tif A[j-1, c] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, c] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[0, c] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\t\tif A[0, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j-1, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\tif k > 0 and k < c:\n\t\t\t# bottom row minus corners edge cases\n\t\t\tif A[0, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j-1, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\t\tif A[0, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j-1, k+1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\n\t\tif k == c:\n\t\t\t# bottom right corner edge cases\n\t\t\tif A[0, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j-1, k-1] == ALIVE:\n\t\t\t\tnum += 1\n\n\t\t\tif A[0, 0] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j, 0] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\tif A[j-1, 0] == ALIVE:\n\t\t\t\tnum += 1\n\t\t\n\t\tif A[j-1,k] == ALIVE:\n\t\t\tnum += 1\n\t\tif A[0, k] == ALIVE:\n\t\t\tnum += 1\n\t\n\treturn num"],"string":"[\n \"def orbit_count(self) -> int:\\n if self.orbit:\\n return 1 + self.orbit.orbit_count()\\n return 0\",\n \"def orbit_count(objects: Dict[str, ObjectMass]) -> int:\\n total = 0\\n\\n for mass in objects.values():\\n total += mass.orbit_count()\\n\\n return total\",\n \"def count():\",\n \"def count_balls(self, **kwargs):\\n return 0\",\n \"def test_number_of_surface_objects(self):\\n for O in self.mod.objts.itervalues():\\n no_of_surfaces = 0\\n for C in O.conts.itervalues():\\n if C.surf != 0:\\n no_of_surfaces += 1\\n self.assertEqual(O.surfsize, no_of_surfaces)\",\n \"def countComponents26(cube):\\n n,l = labelComponents26(cube);\\n return n;\",\n \"def countPanelTrajectoryExpressions(self):\\n nbr = 0\\n for e in self.children:\\n nbr += e.countPanelTrajectoryExpressions()\\n return nbr\",\n \"def get_neighbor_live_count(cart):\\n count = 0\\n for i in range(6):\\n cart2 = (cart[0] + dxv[i],cart[1] + dyv[i],cart[2] + dzv[i])\\n if check_cart(cart2) and voxel_data[cart_to_loc(cart2)] == 1:\\n count += 1\\n return count\",\n \"def count_pegs(self):\\r\\n count = 0\\r\\n\\r\\n for i in range(0, len(self.matrix)):\\r\\n for j in range(0, len(self.matrix[i])):\\r\\n if self.matrix[i][j] == \\\"1\\\":\\r\\n count += 1\\r\\n\\r\\n return count\",\n \"def drawCountPlotPlanets(df):\\n plt.style.use('dark_background')\\n fig, ax = plt.subplots(figsize=(15,8))\\n sns.countplot(x=df.amount_of_planets, data=df, palette='Reds_d')\\n plt.show()\",\n \"def obstacle_count(self):\\n #scan area in front of robot\\n self.scan()\\n #Figure ot how many obstacles there were\\n see_an_object = False\\n count = 0\",\n \"def nbr_tours(self):\\n nbr_tours = 0\\n for i in range(3):\\n for j in range(3):\\n if self.grille[i][j] != 0:\\n nbr_tours += 1\\n return nbr_tours\",\n \"def num_atoms(self):\\n return self.h5['{}/{}'.format(SETTINGS, N_ATOMS)][()]\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def airport_count(airport_data, state_abbr):\\n \\n counter = 0\\n \\n for dat in airport_data:\\n \\n if dat[3] == state_abbr:\\n \\n counter += 1\\n \\n return counter\",\n \"def num_wet(self):\\n return np.sum(self.array == 5)\",\n \"def count_all_atoms(self):\\n n = 0\\n for model in self.iter_models():\\n n += model.count_all_atoms()\\n return n\",\n \"def count_atoms(self):\\n n = 0\\n for chain in self.iter_chains():\\n n += chain.count_atoms()\\n return n\",\n \"def count_atoms(self):\\n n = 0\\n for chain in self.iter_chains():\\n n += chain.count_atoms()\\n return n\",\n \"def total_number_of_animals(self):\\n animals = self.animal()\\n print 'Total number of animals on island: {:4}'.format(\\n animals[\\\"Herbivores\\\"] + animals[\\\"Carnivores\\\"])\",\n \"def get_num_plants(self) -> int:\\r\\n\\r\\n return len(self.plants)\",\n \"def number_of_carnivores_island(self):\\n return np.sum(self.carnivores_on_island)\",\n \"def number_of_atoms(formula):\\n pass\\n # ======== YOUR CODE HERE ========\",\n \"def count(self, syms = None ):\\n if syms == None:\\n syms = self.alpha.getSymbols()\\n for sym in syms:\\n idx = self.alpha.getIndex( sym )\\n self.cnt[idx] += 1.0\\n self.tot += 1\",\n \"def getNumTiles(self):\\n return len(list(product(list(range(self.width+1))[1:], list(range(self.height+1))[1:])))\",\n \"def obstacle_count(self):\\n self.wide_scan()\\n found_something = False\\n counter = 0\\n for distance in self.scan:\\n if distance and distance < 200 and not found_something:\\n found_something = True\\n counter += 1\\n print(\\\"Object # %d found, I think\\\" % counter)\\n if distance and distance > 200 and found_something:\\n found_something = False\\n print(\\\"\\\\n----I SEE %d OBJECTS----\\\\n\\\" % counter)\",\n \"def count_all_atoms(self):\\n n = 0\\n for atm in self.atom_order_list:\\n if isinstance(atm, Atom):\\n n += 1\\n else:\\n n += len(atm)\\n return n\",\n \"def Points_Counting(self):\\n return len(self.__traectory_list)\",\n \"def get_num_markets(add):\\r\\n name=get_zipcode_names(add)\\r\\n engine = get_sql_engine()\\r\\n number_markets = text(\\r\\n \\\"\\\"\\\"\\r\\n SELECT COUNT(\\\"NAME\\\") AS num_markets\\r\\n FROM farmers_markets\\r\\n WHERE \\\"ZIP\\\" = :name\\r\\n \\\"\\\"\\\"\\r\\n )\\r\\n resp = engine.execute(number_markets, name=name).fetchone()\\r\\n return resp[\\\"num_markets\\\"]\",\n \"def n_tracers(self):\\n # Extract parameters\\n pzs = self.params[0]\\n return len(pzs)\",\n \"def n_tracers(self):\\n # Extract parameters\\n pzs = self.params[0]\\n return len(pzs)\",\n \"def getNumberOfTraces(self) -> int:\\n\\n if not self.debug:\\n self.myFieldFox.write(\\\"CALC:PAR:COUN?\\\")\\n ret = self.myFieldFox.read()\\n else:\\n ret = 4\\n return ret\",\n \"def count(self, volume):\\n\\n countResult = 0\\n\\n for x in range(volume.shape[0]):\\n for y in range(volume.shape[1]):\\n for z in range(volume.shape[2]):\\n if self.isMember(volume[x,y,z]):\\n countResult += 1\\n\\n return countResult\",\n \"def n_rays(self):\\n try: \\n return self._n_rays\\n except AttributeError:\\n self._n_rays = 0\\n for r in self.rays(): self._n_rays += 1\\n return self._n_rays\",\n \"def num_trajs(self):\\n return len(list(self.run_traj_idx_tuples()))\",\n \"def countPanelTrajectoryExpressions(self):\\n return 1 + self.child.countPanelTrajectoryExpressions()\",\n \"def number_of_atoms(self):\\n if self._number_of_atoms is None:\\n if self.mol is not None:\\n self._number_of_atoms = len(self.mol.atoms)\\n elif not self.is_ts:\\n self._number_of_atoms = len(self.get_xyz().splitlines())\\n return self._number_of_atoms\",\n \"def count_timepoints(sc, session, files):\\n tuples = zip(range(len(files)), files)\\n files_sc = sc.parallelize(tuples)\\n\\n def count_planes(kv):\\n index, path2 = kv\\n try:\\n from ScanImageTiffReader import ScanImageTiffReader\\n img = ScanImageTiffReader(path2).data()\\n except Exception:\\n import tifffile\\n img = tifffile.imread(path2)\\n return img.shape[0]\\n\\n data2 = files_sc.map(count_planes).collect()\\n frame_numbers = np.array(data2)\\n vol_numbers = frame_numbers / len(session.fieldMask)\\n return vol_numbers.astype(int)\",\n \"def get_num_streets(market):\\r\\n return len(market)\",\n \"def count() -> int:\\n pass\",\n \"def voxel_count(self):\\n return self.cols * self.rows * self.sections\",\n \"def main():\\n row, col, island = make_matrix()\\n print(count_island(row, col, island))\",\n \"def obstacle_count(self):\\n for x in range(6):\\n # do a scan of the area in front of the robot\\n self.scan()\\n\\n \\n see_an_object = False\\n count = 0 \\n # Do a scan and count the amount of objects in the way\\n for angle in self.scan_data:\\n dist = self.scan_data[angle]\\n if dist < self.SAFE_DISTANCE and not see_an_object: \\n see_an_object = True\\n count += 1\\n print(\\\"~~~ I SEE SOMETHING!! ~~~\\\")\\n elif dist > self.SAFE_DISTANCE and see_an_object:\\n see_an_object = False\\n print(\\\"I guess the object ended\\\") \\n print(\\\"ANGLE: %d | DIST: %d\\\" % (angle, dist))\\n self.turn_by_deg(90)\\n print(\\\"\\\\nI saw %d objects\\\" % count)\",\n \"def getnumbarablocktriplets(self): # 3\\n res,resargs = self.__obj.getnumbarablocktriplets()\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n _num_return_value = resargs\\n return _num_return_value\",\n \"def number_of_herbivores_island(self):\\n return np.sum(self.herbivores_on_island)\",\n \"def get_orbit_hops(self) -> Dict[str, int]:\\n total = 0\\n orbit_hops = {}\\n\\n orbit = self.orbit\\n\\n while orbit:\\n orbit_hops[orbit.name] = total\\n orbit = orbit.orbit\\n total += 1\\n\\n return orbit_hops\",\n \"def count(self):\\n return self.vcount\",\n \"def count(self):\\n return len(self._components)\",\n \"def count_waters(self):\\n n = 0\\n for frag in self.iter_waters():\\n n += 1\\n return n\",\n \"def _count_parties(data_set): #DEMOCRATS, THEN REPUBLICANS\\r\\n reps = 0\\r\\n dems = 0\\r\\n for data_point in data_set:\\r\\n if data_point.dat_party == \\\"R\\\": reps+=1\\r\\n if data_point.dat_party == \\\"D\\\": dems+=1\\r\\n\\r\\n return (dems, reps)\",\n \"def get_number_of_atoms_to_optimize(self):\\n v = self.c.get(simulation_cell=True)\\n return len(v.data.stoichiometry)\",\n \"def count_support(projection):\\n\\tprev_id = -1\\n\\tsize = 0\\n\\tfor p in projection:\\n\\t\\tif prev_id != p.id:\\n\\t\\t\\tprev_id = p.id\\n\\t\\t\\tsize += 1\\n\\treturn size\",\n \"def numel(self):\\n return self.t.size\",\n \"def nb_triples(self) -> int:\\n return 0\",\n \"def nAtoms(self, species = None, element = None):\\n try:\\n m = self.elementIndex(element)\\n k = self.speciesIndex(species)\\n na = _cantera.phase_natoms(self._phase_id, k, m)\\n #if na < 0: return 0\\n return na\\n except CanteraError:\\n return 0\",\n \"def atom_count(self):\\n return len(self.repeated_elements())\",\n \"def getNumTiles(self):\\n return (self.width) * (self.height)\",\n \"def count_all_atoms(self):\\n n = 0\\n for chain in self.iter_chains():\\n n += chain.count_all_atoms()\\n return n\",\n \"def count(self):\\n # TODO not implemented yet\\n return 0\",\n \"def getNumTiles(self):\\n\\t\\treturn self.numTiles\",\n \"def number_of_constituents(bc_class):\\n num_trn = 0\\n cn = bc_class.constituent_properties\\n if cn.salinity:\\n num_trn += 1\\n if cn.temperature:\\n num_trn += 1\\n if cn.vorticity:\\n num_trn += 1\\n if not cn.general_constituents.empty:\\n num_trn += len(cn.general_constituents.index)\\n if not cn.sand.empty:\\n num_trn += len(cn.sand.index)\\n if not cn.clay.empty:\\n num_trn += len(cn.clay.index)\\n return num_trn\",\n \"def all_valid(self, tower) -> int:\\r\\n count = 0\\r\\n for layer in range(1, len(tower.tower)):\\r\\n for index in range(1, 4):\\r\\n if self.is_valid(layer, index, tower):\\r\\n count += 1\\r\\n \\r\\n return count\",\n \"def count(self):\\n\\n raise NotImplementedError\",\n \"def N(self):\\n return len(self.cavity_grid.cavities) + 1\",\n \"def gal_count(clusters):\\n sum = 0\\n for x in clusters:\\n sum += x.ngal\\n return sum\",\n \"def num_injectors(self):\\n injectors = self.info_wells.groupby('well_type').get_group('inj')\\n return injectors['well'].nunique()\",\n \"def get_number_of_ions(exp_builder, phase, system_id):\\n # Read in output pdb file to read ionic strength.\\n if phase == 'complex' or phase == 'solvent1':\\n phase_id = 0\\n else:\\n phase_id = 1\\n system_filepath = exp_builder._db.get_system_files_paths(system_id)[phase_id].position_path\\n system_filepath = os.path.splitext(system_filepath)[0] + '.pdb'\\n system_traj = mdtraj.load(system_filepath)\\n\\n # Count number of waters and ions.\\n n_waters = 0\\n n_pos_ions = 0\\n n_neg_ions = 0\\n for res in system_traj.topology.residues:\\n if res.is_water:\\n n_waters += 1\\n elif '+' in res.name:\\n n_pos_ions += 1\\n elif '-' in res.name:\\n n_neg_ions += 1\\n\\n # Verify that number of ions roughly models the expected ionic strength.\\n try:\\n solvent_id = exp_builder._db.systems[system_id]['solvent']\\n except KeyError:\\n solvent_id = exp_builder._db.systems[system_id][phase] # solvent1 or solvent2\\n ionic_strength = exp_builder._db.solvents[solvent_id]['ionic_strength']\\n n_ionic_strength_ions = int(np.round(n_waters * ionic_strength / (55.41*unit.molar)))\\n\\n return n_pos_ions, n_neg_ions, n_ionic_strength_ions\",\n \"def numAtoms(self):\\n return self.nAtoms\",\n \"def get_numberOfProjections(self):\\n self._nproj = len(self._projIndices)\\n return self._nproj\",\n \"def count(self, trace):\\n return len(trace)\",\n \"def natoms(self):\\n return len(self.atoms)\",\n \"def noOfPlayers(self):\\n\\t\\tnumber = 0\\n\\t\\tfor n in range(6):\\n\\t\\t\\tif self.playerList[n] != None:\\n\\t\\t\\t\\tnumber = number + 1\\n\\t\\treturn number\",\n \"def ir_count(self) -> int:\\n return int(self.graph_tuple_stats.ir_count or 0)\",\n \"def count_rotation_numels(model):\\n total = 0\\n for m in model.modules():\\n if isinstance(m, (ConvLayerRotation, LinearLayerRotation)):\\n total += m.rotation_matrix.numel()\\n return total\",\n \"def __len__(self):\\n i = 0\\n for S in self.states():\\n i += 1\\n return i\",\n \"def getNrStations(self):\\n return len(self.stationData)\",\n \"def get_num_petals(self):\\n return self._num_petals\",\n \"def get_vehicle_count(self):\\n return len(self.vehicles)\",\n \"def num_ellipsoids(self):\\n return self._shape_count(_sff.ellipsoid)\",\n \"def get_number_of_ocean_levels(description):\\n\\n if description == \\\"none\\\":\\n return \\\"0\\\"\\n elif re.search(\\\"levels\\\", description):\\n match = re.search(\\\"(?P<nlo>\\\\d+)\\\\s?(levels|vertical levels)\\\", description)\\n return match.groupdict()[\\\"nlo\\\"]\\n else:\\n return \\\"60\\\"\",\n \"def numAtoms(self):\\n\\n\\t\\tnatoms = 0\\n\\t\\tfor chain in self.chain:\\n\\t\\t\\tfor residue in chain.residue:\\n\\t\\t\\t\\tnatoms += residue.numAtoms()\\n\\n\\t\\treturn natoms\",\n \"def total_num_atoms(self):\\n return self.GetNumberOfAtoms()\",\n \"def getNumTiles(self):\\n return self.height * self.width\",\n \"def __len__(self):\\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios\",\n \"def __len__(self):\\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios\",\n \"def __len__(self):\\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios\",\n \"def __len__(self):\\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios\",\n \"def get_num_of_baskets(self):\\n return self.num_of_baskets\",\n \"def _count_explores(self) -> int:\\n explore_count = 0\\n for model in self.project.models:\\n explore_count += len(model.explores)\\n return explore_count\",\n \"def n_pos(self):\\n running_total = 0\\n for i in range(self.prob.num):\\n if self.alphas[i] > 1e-5 > self.prob.C - self.deltas[i] and self.prob.Y[i] == 1:\\n running_total += 1\\n return running_total if running_total > 0 else 1\",\n \"def n_pos(self):\\n running_total = 0\\n for i in range(self.prob.num):\\n if self.alphas[i] > 1e-5 > self.prob.C - self.deltas[i] and self.prob.Y[i] == 1:\\n running_total += 1\\n return running_total if running_total > 0 else 1\",\n \"def lives_counter(self):\\n count = 15\\n for row in self.board:\\n for column in row:\\n if column == HITSHIP:\\n count -= 1\\n self.lives = count\\n return self.lives\",\n \"def GetNumberOfVariables(self):\\n\\n # nvar = 0\\n # for i in self.variables_order:\\n # # DO NOT COUNT VARIABLES THAT GET CONDENSED OUT\\n # if i!=0:\\n # if mesh.element_type == \\\"tri\\\":\\n # nvar += (i+1)*(i+2) // 2\\n # elif mesh.element_type == \\\"tet\\\":\\n # nvar += (i+1)*(i+2)*(i+3) // 6\\n # elif mesh.element_type == \\\"quad\\\":\\n # nvar += (i+1)**2\\n # elif mesh.element_type == \\\"hex\\\":\\n # nvar += (i+1)**3\\n\\n # nvar = sum(self.variables_order)\\n if self.nvar == None:\\n self.nvar = self.ndim\\n return self.nvar\",\n \"def num_animals(self):\\n return self._num_herbs + self._num_carns\",\n \"def getNumTiles(self):\\n return self.w * self.h\",\n \"def n_atoms(self) -> int:\\n return 0 if self.atoms is None else len(self.atoms)\",\n \"def num_nbrs_torus(A, r, j, c, k):\\n\\tnum = 0\\n\\tr = r - 1 # to account for off by one errors\\n\\tc = c - 1\\n\\tif j == 0:\\n\\t\\tif k == 0:\\n\\t\\t\\t# top left corner edge case\\n\\t\\t\\tif A[r, c] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, c] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, c] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\t\\tif A[r, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\tif k > 0 and k < c:\\n\\t\\t\\t# top row minus corners edge cases\\n\\t\\t\\tif A[r, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\t\\tif A[r, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\n\\t\\tif k == c:\\n\\t\\t\\t# top right corner edge case\\n\\t\\t\\tif A[r, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\t\\tif A[r, 0] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, 0] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, 0] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\n\\t\\tif A[j+1,k] == ALIVE:\\n\\t\\t\\tnum += 1\\n\\t\\tif A[r, k] == ALIVE:\\n\\t\\t\\tnum += 1\\n\\n\\tif j > 0 and j < r:\\n\\t\\tif k == 0:\\n\\t\\t\\t# left side minus corners edge cases\\n\\t\\t\\tif A[j-1, c] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, c] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, c] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\t\\tif A[j-1, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\tif k > 0 and k < c:\\n\\t\\t\\t# center\\n\\t\\t\\tif A[j-1, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\t\\tif A[j-1, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\n\\t\\tif k == c:\\n\\t\\t\\t# right side minus corners edge cases\\n\\t\\t\\tif A[j-1, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\t\\tif A[j-1, 0] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, 0] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j+1, 0] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\n\\t\\tif A[j+1,k] == ALIVE:\\n\\t\\t\\tnum += 1\\n\\t\\tif A[j-1, k] == ALIVE:\\n\\t\\t\\tnum += 1\\n\\n\\n\\tif j == r:\\n\\t\\tif k == 0:\\n\\t\\t\\t# bottom left corner edge cases\\n\\t\\t\\tif A[j-1, c] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, c] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[0, c] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\t\\tif A[0, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j-1, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\tif k > 0 and k < c:\\n\\t\\t\\t# bottom row minus corners edge cases\\n\\t\\t\\tif A[0, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j-1, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\t\\tif A[0, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j-1, k+1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\n\\t\\tif k == c:\\n\\t\\t\\t# bottom right corner edge cases\\n\\t\\t\\tif A[0, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j-1, k-1] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\n\\t\\t\\tif A[0, 0] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j, 0] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\tif A[j-1, 0] == ALIVE:\\n\\t\\t\\t\\tnum += 1\\n\\t\\t\\n\\t\\tif A[j-1,k] == ALIVE:\\n\\t\\t\\tnum += 1\\n\\t\\tif A[0, k] == ALIVE:\\n\\t\\t\\tnum += 1\\n\\t\\n\\treturn num\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7507539","0.72100306","0.617972","0.6152469","0.61030316","0.603404","0.6009309","0.5947875","0.59461266","0.5906092","0.5883676","0.5869086","0.58329415","0.5806103","0.5806103","0.5806103","0.5806103","0.577206","0.574075","0.57232994","0.57174265","0.57174265","0.56978667","0.5690096","0.56874657","0.56598604","0.56567085","0.56392145","0.5636239","0.5634523","0.5625791","0.56198424","0.5619639","0.5619639","0.5613094","0.55897135","0.5588809","0.55753696","0.55742574","0.55730665","0.5572822","0.5562752","0.55625284","0.55289274","0.5520585","0.55070835","0.55019325","0.55006886","0.5496928","0.54943734","0.5489772","0.5481818","0.5481797","0.5468241","0.5468083","0.54626596","0.5462629","0.5457187","0.54426366","0.54416436","0.5427329","0.54249084","0.54223293","0.541635","0.5407243","0.5402466","0.54001045","0.5385608","0.5384107","0.53811646","0.5376768","0.53733367","0.5364865","0.5363121","0.53520143","0.53505963","0.5349892","0.5347887","0.5347176","0.5337795","0.5336007","0.5334661","0.5334219","0.5330905","0.5324562","0.53201324","0.5316428","0.5316428","0.5316428","0.5316428","0.5311232","0.5308357","0.53081965","0.53081965","0.53042156","0.5299123","0.5294308","0.5292634","0.52873975","0.52872354"],"string":"[\n \"0.7507539\",\n \"0.72100306\",\n \"0.617972\",\n \"0.6152469\",\n \"0.61030316\",\n \"0.603404\",\n \"0.6009309\",\n \"0.5947875\",\n \"0.59461266\",\n \"0.5906092\",\n \"0.5883676\",\n \"0.5869086\",\n \"0.58329415\",\n \"0.5806103\",\n \"0.5806103\",\n \"0.5806103\",\n \"0.5806103\",\n \"0.577206\",\n \"0.574075\",\n \"0.57232994\",\n \"0.57174265\",\n \"0.57174265\",\n \"0.56978667\",\n \"0.5690096\",\n \"0.56874657\",\n \"0.56598604\",\n \"0.56567085\",\n \"0.56392145\",\n \"0.5636239\",\n \"0.5634523\",\n \"0.5625791\",\n \"0.56198424\",\n \"0.5619639\",\n \"0.5619639\",\n \"0.5613094\",\n \"0.55897135\",\n \"0.5588809\",\n \"0.55753696\",\n \"0.55742574\",\n \"0.55730665\",\n \"0.5572822\",\n \"0.5562752\",\n \"0.55625284\",\n \"0.55289274\",\n \"0.5520585\",\n \"0.55070835\",\n \"0.55019325\",\n \"0.55006886\",\n \"0.5496928\",\n \"0.54943734\",\n \"0.5489772\",\n \"0.5481818\",\n \"0.5481797\",\n \"0.5468241\",\n \"0.5468083\",\n \"0.54626596\",\n \"0.5462629\",\n \"0.5457187\",\n \"0.54426366\",\n \"0.54416436\",\n \"0.5427329\",\n \"0.54249084\",\n \"0.54223293\",\n \"0.541635\",\n \"0.5407243\",\n \"0.5402466\",\n \"0.54001045\",\n \"0.5385608\",\n \"0.5384107\",\n \"0.53811646\",\n \"0.5376768\",\n \"0.53733367\",\n \"0.5364865\",\n \"0.5363121\",\n \"0.53520143\",\n \"0.53505963\",\n \"0.5349892\",\n \"0.5347887\",\n \"0.5347176\",\n \"0.5337795\",\n \"0.5336007\",\n \"0.5334661\",\n \"0.5334219\",\n \"0.5330905\",\n \"0.5324562\",\n \"0.53201324\",\n \"0.5316428\",\n \"0.5316428\",\n \"0.5316428\",\n \"0.5316428\",\n \"0.5311232\",\n \"0.5308357\",\n \"0.53081965\",\n \"0.53081965\",\n \"0.53042156\",\n \"0.5299123\",\n \"0.5294308\",\n \"0.5292634\",\n \"0.52873975\",\n \"0.52872354\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6075204"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":3187,"cells":{"query":{"kind":"string","value":"This function identify on which orbits it is possible to meet santa with the least number of jumps"},"document":{"kind":"string","value":"def meet_santa(orbitDict):\n santa_count, santa_path = does_orbit('SAN', orbitDict)\n your_count, your_path = does_orbit('YOU', orbitDict)\n santa_planets = set(santa_path)\n your_planets = set(your_path)\n common = len(santa_planets.intersection(your_planets))\n dist = santa_count + your_count - 2*common\n return dist"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def spotlessroomba_first_heuristic(state : SpotlessRoombaState) -> float:\n # TODO a nontrivial admissible heuristic\n return len(state.dirty_locations)","def challenge1(self):\n self.parse_input()\n\n # Find strongest nanobot\n strongest = max(self.nanobots, key=lambda n: n.r)\n\n # Find all in range of this\n num_in_range = 0\n for nanobot in self.nanobots:\n if manhattan_dist(nanobot.coord, strongest.coord) <= strongest.r:\n num_in_range += 1\n\n print(f\"{num_in_range} nanobots are in range of strongest\")","def bridge_problem3(here):\r\n\r\n def all_over(state):\r\n here, _ = state\r\n return not here or here == set([\"light\"])\r\n\r\n start = (frozenset(here) | frozenset([\"light\"]), frozenset())\r\n return lowest_cost_search(start, bsuccessors2, all_over, bcost)","def shortest_tips(neuron):\n (branch_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 2)\n (endpoint_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 0)\n selected_index = np.union1d(endpoint_index + 1,\n branch_index + 1)\n selected_index = np.append(0, selected_index)","def obstacle_count(self):\n self.wide_scan()\n found_something = False\n counter = 0\n for distance in self.scan:\n if distance and distance < 200 and not found_something:\n found_something = True\n counter += 1\n print(\"Object # %d found, I think\" % counter)\n if distance and distance > 200 and found_something:\n found_something = False\n print(\"\\n----I SEE %d OBJECTS----\\n\" % counter)","def brute_force_search_solution():\n return len(coin_search(TOTAL, COINS))","def minimum_spanning_arborescence(sol):","def count_stair_ways(n):\n if n == 1:\n return 1\n if n == 2:\n return 2\n return count_stair_ways(n - 1) + count_stair_ways(n - 2)","def large_neighborhood_search(facilities: list, towns: list, hazards: list, max_iteration: int = 50, max_improvement: int = 10) -> tuple:\r\n\r\n # counters\r\n max_attempts_per_swappable_facility = 10\r\n attempts_per_swappable_facility = 0\r\n improvements = 0\r\n iterations = 0\r\n\r\n # list of the opened facilities\r\n solutions = list(filter(lambda o_facility: o_facility.is_open, facilities.copy()))\r\n\r\n while True:\r\n\r\n # list of the closed facilities\r\n neighborhood = list(filter(lambda c_facility: not c_facility.is_open, facilities.copy()))\r\n\r\n # get the town with the maximum hazard perceived\r\n max_hazard_town, max_hazard = get_town_with_max_hazard(facilities, towns, hazards)\r\n\r\n # get a random opened facility to close\r\n swappable_facility = random.choice(solutions)\r\n\r\n while True:\r\n # get a random closed facility to test\r\n test_facility = random.choice(neighborhood)\r\n\r\n # check capacity constraint (ADMISSIBILITY)\r\n if test_facility.capacity >= swappable_facility.capacity:\r\n # destroy & repair the solution\r\n swappable_facility.is_open = False\r\n test_facility.is_open = True\r\n\r\n # calculate the new max hazard and the respective town\r\n new_max_hazard_town, new_max_hazard = get_town_with_max_hazard(facilities, towns, hazards)\r\n\r\n # check if the new max hazard is an improvement (SOLUTION)\r\n if new_max_hazard < max_hazard:\r\n # reassign the chosen facility to the towns whose were associated with the swappable_facility\r\n for town in towns:\r\n if town.facility == swappable_facility:\r\n town.facility = test_facility\r\n\r\n # reset the attempts per town counter because now there is a new solution to iterate on\r\n improvements += 1\r\n\r\n # rebuild the solution\r\n solutions = list(filter(lambda o_facility: o_facility.is_open, facilities.copy()))\r\n\r\n # exit the loop because a solution was found\r\n break\r\n\r\n else:\r\n # restore of the current solution's data structures\r\n swappable_facility.is_open = True\r\n test_facility.is_open = False\r\n\r\n # skip the chosen facility\r\n neighborhood.pop(neighborhood.index(test_facility))\r\n\r\n else:\r\n # skip the chosen facility\r\n neighborhood.pop(neighborhood.index(test_facility))\r\n\r\n # increment the counter for swappable facility attempts to swap, then check the limit and maybe break\r\n attempts_per_swappable_facility += 1\r\n # forbid the current swappable facility to be taken in a count for the next iteration\r\n if len(neighborhood) == 0 or attempts_per_swappable_facility == max_attempts_per_swappable_facility:\r\n solutions.pop(solutions.index(swappable_facility))\r\n break\r\n\r\n # if there are no more facilities in solution to be taken in account, exit the loop\r\n if len(solutions) == 0:\r\n break\r\n\r\n # check the number of improvement\r\n if improvements == max_improvement:\r\n break\r\n\r\n iterations += 1\r\n # check the number of iteration\r\n if iterations == max_iteration:\r\n break\r\n\r\n return iterations, improvements","def sky_orbits(test=True):\n \n t = Table.read('/home/ana/data/baumgardt_positions.fits')\n \n ind_disterr = ~np.isfinite(t['e_Rsun'])\n t['e_Rsun'][ind_disterr] = 0.1 * t['Rsun'][ind_disterr]\n e_max = np.nanmax(t['e_Rsun'][~ind_disterr])\n ind_cap = t['e_Rsun']>e_max\n t['e_Rsun'][ind_cap] = e_max\n \n clusters = ['NGC 3201', 'NGC 4590', 'NGC 5824', 'NGC 5272', 'NGC 5139', 'NGC 5024']\n #clusters = ['NGC 5824', 'NGC 5024']\n N = len(clusters)\n \n match = dict()\n match['NGC 3201'] = dict(streams=['gjoll'], direction=[-1], nstep=[35], gc_label='NGC\\n3201', gcra_off=0*u.deg, gcdec_off=-13*u.deg, gcl_off=0*u.deg, gcb_off=-13*u.deg, stream_label=['$Gj\\\\\\\" oll$'], stream_ra=[-156*u.deg], stream_dec=[-4.5*u.deg], eq_angle=[-45*u.deg], stream_l=[-148*u.deg], stream_b=[-33*u.deg], gal_angle=[22*u.deg])\n \n match['NGC 4590'] = dict(streams=['fjorm'], direction=[1], nstep=[100], gc_label='NGC\\n4590', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=-13*u.deg, gcb_off=-10*u.deg, stream_label=['$Fj\\\\\\\" orm$'], stream_ra=[-22*u.deg], stream_dec=[66*u.deg], eq_angle=[35*u.deg], stream_l=[110*u.deg], stream_b=[50*u.deg], gal_angle=[-50*u.deg])\n \n match['NGC 5024'] = dict(streams=['sylgr', 'ravi'], direction=[-1, 1], nstep=[300,500], gc_label='NGC\\n5024', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=10*u.deg, gcb_off=-20*u.deg, stream_label=['Sylgr', 'Ravi'], stream_ra=[-70*u.deg, 83*u.deg], stream_dec=[2*u.deg, -47*u.deg], eq_angle=[25*u.deg, 65*u.deg], stream_l=[-110*u.deg, -18.5*u.deg], stream_b=[62*u.deg, -47*u.deg], gal_angle=[30*u.deg, -10*u.deg])\n \n match['NGC 5139'] = dict(streams=['fimbulthul'], direction=[-1], nstep=[70], gc_label='NGC\\n5139', gcra_off=-5*u.deg, gcdec_off=-15*u.deg, gcl_off=0*u.deg, gcb_off=-12*u.deg, stream_label=['Fimbulthul'], stream_ra=[-20*u.deg], stream_dec=[-15*u.deg], eq_angle=[0*u.deg], stream_l=[-20*u.deg], stream_b=[45*u.deg], gal_angle=[0*u.deg])\n \n match['NGC 5272'] = dict(streams=['svol'], direction=[1], nstep=[70], gc_label='NGC\\n5272', gcra_off=-15*u.deg, gcdec_off=10*u.deg, gcl_off=-23*u.deg, gcb_off=-17*u.deg, stream_label=['$Sv\\\\\\\" ol$'], stream_ra=[-2*u.deg], stream_dec=[34*u.deg], eq_angle=[-10*u.deg], stream_l=[55*u.deg], stream_b=[55*u.deg], gal_angle=[-65*u.deg])\n \n match['NGC 5824'] = dict(streams=['triangulum', 'turbio'], direction=[1,1], nstep=[700,1], gc_label='NGC\\n5824', gcra_off=15*u.deg, gcdec_off=-5*u.deg, gcl_off=15*u.deg, gcb_off=-5*u.deg, stream_label=['Triangulum', 'Turbio'], stream_ra=[152*u.deg, 130*u.deg], stream_dec=[32*u.deg, -51*u.deg], eq_angle=[-48*u.deg, 30*u.deg], stream_l=[120*u.deg, -82*u.deg], stream_b=[-31*u.deg, -57*u.deg], gal_angle=[70*u.deg, 105*u.deg])\n \n dt = 0.5*u.Myr\n wangle = 180*u.deg\n ra_off = 120*u.deg\n l_off = 0*u.deg\n \n colors = [mpl.cm.plasma(0.95*x/N) for x in range(N)]\n \n np.random.seed(27529)\n if test:\n Nsample = 1\n else:\n Nsample = 100\n \n plt.close()\n fig = plt.figure(figsize=(12,12))\n \n ax0 = fig.add_subplot(211, projection='mollweide')\n ax1 = fig.add_subplot(212, projection='mollweide')\n ax = [ax0, ax1]\n \n for i in range(N):\n #ind = t['Name']== clusters[i]\n ind = t['Name']==clusters[i]\n t_ = t[ind]\n \n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\n cgal = c.transform_to(coord.Galactic)\n #w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\n \n color = colors[i]\n alpha_text = 0.8\n \n plt.sca(ax[0])\n plt.plot((c.ra + ra_off).wrap_at(wangle).rad, c.dec.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\n plt.text((c.ra + ra_off + match[clusters[i]]['gcra_off']).wrap_at(wangle).rad, (c.dec + match[clusters[i]]['gcdec_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\n \n plt.sca(ax[1])\n plt.plot((cgal.l + l_off).wrap_at(wangle).rad, cgal.b.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\n plt.text((cgal.l + l_off + match[clusters[i]]['gcl_off']).wrap_at(wangle).rad, (cgal.b + match[clusters[i]]['gcb_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\n \n\n for j in range(len(match[clusters[i]]['direction'])):\n # sample gc positional uncertainties\n for k in range(-1, Nsample):\n if k==-1:\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\n \n lw = 1.5\n alpha = 1\n else:\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'] + np.random.randn()*t_['e_Rsun'], pm_ra_cosdec=t_['pmRA_'] + np.random.randn()*t_['e_pmRA_'], pm_dec=t_['pmDE'] + np.random.randn()*t_['e_pmDE'], radial_velocity=t_['RV'] + np.random.randn()*t_['e_RV'], frame='icrs')\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\n \n lw = 1\n alpha = 0.1\n \n orbit = ham.integrate_orbit(w0, dt=dt*match[clusters[i]]['direction'][j], n_steps=match[clusters[i]]['nstep'][j])\n orbit_eq = orbit.to_coord_frame(coord.ICRS, galactocentric_frame=gc_frame)\n orbit_gal = orbit.to_coord_frame(coord.Galactic, galactocentric_frame=gc_frame)\n \n \n plt.sca(ax[0])\n dra = (orbit_eq.ra+ra_off).wrap_at(wangle)[1:] - (orbit_eq.ra+ra_off).wrap_at(wangle)[:-1]\n if np.any(np.abs(dra)>180*u.deg):\n pos_break = dra>180*u.deg\n ind_break = np.argmax(pos_break)\n ipad = 1\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_eq.dec.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_eq.dec.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\n else:\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad, orbit_eq.dec.rad, '-', color=color, lw=lw, label='', alpha=alpha)\n \n plt.sca(ax[1])\n dl = orbit_gal.l.wrap_at(wangle)[1:] - orbit_gal.l.wrap_at(wangle)[:-1]\n if np.any(np.abs(dl)>180*u.deg):\n pos_break = dl>180*u.deg\n ind_break = np.argmax(pos_break)\n ipad = 1\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_gal.b.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_gal.b.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\n else:\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad, orbit_gal.b.rad, '-', color=color, lw=lw, label='', alpha=alpha)\n \n # add streams\n pkl = pickle.load(open('../data/streams/data_{:s}.pkl'.format(match[clusters[i]]['streams'][j]), 'rb'))\n cs = coord.SkyCoord(ra=pkl['dec'][0], dec=pkl['dec'][1], frame='icrs')\n cs_gal = cs.transform_to(coord.Galactic)\n \n plt.sca(ax[0])\n plt.plot((cs.ra+ra_off).wrap_at(wangle).rad, cs.dec.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\n plt.text(coord.Longitude(match[clusters[i]]['stream_ra'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_dec'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['eq_angle'][j].value, ha='center', va='center')\n \n plt.sca(ax[1])\n plt.plot((cs_gal.l+l_off).wrap_at(wangle).rad, cs_gal.b.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\n plt.text(coord.Longitude(match[clusters[i]]['stream_l'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_b'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['gal_angle'][j].value, ha='center', va='center')\n \n \n plt.sca(ax[0])\n plt.grid(ls=':')\n plt.xlabel('R.A. [deg]')\n plt.ylabel('Dec [deg]')\n\n plt.gca().xaxis.set_ticklabels([])\n \n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\n xloc = np.delete(xloc, [3])\n yloc = coord.Latitude(5*u.deg)\n Nx = len(xloc)\n \n for i in range(Nx):\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\degree$'.format((xloc[i]-ra_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\n \n \n plt.sca(ax[1])\n plt.grid(ls=':')\n plt.xlabel('Galactic longitude [deg]')\n plt.ylabel('Galactic latitude [deg]')\n \n plt.gca().xaxis.set_ticklabels([])\n \n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\n xloc = np.delete(xloc, [2,3])\n yloc = coord.Latitude(5*u.deg)\n Nx = len(xloc)\n \n for i in range(Nx):\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\degree$'.format((xloc[i]+l_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\n \n \n \n plt.tight_layout(h_pad=2)\n plt.savefig('../paper/sky_orbits.pdf')","def branchNBound2(nationtxt, bound, scheme):\n\n\n nation = nationLoader(nationtxt)\n transmitterCosts = scheme\n\n neighborCount = {}\n for province in nation:\n neighborCount.update({province:len(nation.get(province)[0])})\n\n\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\n\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\n\n for key in neighborCountSorted:\n provinces.append(key)\n #~ print provinces\n\n upperbound = bound\n #~ print bound\n\n\n\n solution = []\n\n\n counter = 0\n\n\n\n\n while index >= 0:\n\n counter += 1\n if counter % 100000000 == 0:\n print counter\n print \"Now at:\", nation\n\n\n if index == -1:\n break\n\n # Assign transmitter\n if nation[provinces[index]][1] == numTransmitters:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n else:\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\n\n # Check if costs are above upper bound\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n # Check if a neighbor has the same transmitter\n conflict = False\n for neighbor in nation[provinces[index]][0]:\n if nation[neighbor][1] == nation[provinces[index]][1]:\n conflict = True\n break\n\n if conflict:\n continue\n\n # Check if a solution is found\n if index == len(provinces) - 1:\n #~ print \"\\nSOLUTION:\"\n if costs < upperbound:\n solution = []\n solution.append(json_deep_copy(nation))\n upperbound = costs\n #~ print \"Score:\", upperbound\n #~ print nation\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n index += 1\n\n\n\n usedTrans = []\n fivePlus = 0\n fivePlusNoDuplicate = 0\n\n for nation in solution:\n\n one = 0\n two = 0\n three = 0\n four = 0\n five = 0\n six = 0\n seven = 0\n\n for province in nation:\n\n if nation[province][1] == 1:\n one += 1\n if nation[province][1] == 2:\n two += 1\n if nation[province][1] == 3:\n three += 1\n if nation[province][1] == 4:\n four += 1\n if nation[province][1] == 5:\n five += 1\n if nation[province][1] == 6:\n six += 1\n if nation[province][1] == 7:\n seven += 1\n\n\n if five > 0 or six > 0 or seven > 0:\n fivePlus += 1\n if transmitterCosts[3] != transmitterCosts[4]:\n fivePlusNoDuplicate += 1\n\n usedTrans.append([one, two, three, four, five, six, seven])\n\n return counter","def heads_legs(heads, legs):\n for i in range(0, heads + 1):\n cows = heads - i\n if 4 * cows + 2 * i == legs:\n chickens = i\n return chickens, cows\n return \"No solutions.\"","def earliest_arrival(jump_distance, stones):\n #jump_distance of 3 means they skip 2 stones and land on 3rd\n stone = ''\n #based on jump_distance, what are all the stone nums within that distance\n #when jump_distance is 5, can jujp to stones[4]\n \n stone = min(stones[:(jump_distance - 1)]) #stone = 2\n\n t = max(0, stone) #t = 2\n print(f't starts at = {t}')\n i = stones.index(stone) # i = 1\n print(f'i starts at = {i}') \n #as long as \n while i + jump_distance <= len(stones) - 1: # 3 + 5 <= 7\n print(f'i + jump_distance = {i + jump_distance}')\n\n stone = min(stones[(i + 1):(i + jump_distance)]) #stone = 3\n print(f'stone: {stone}')\n if t < stone: \n t = stone #reassign to 3\n \n i = stones.index(stone) # i = 2\n print(f'i = {i}') \n stone = min(stones[(i + 1):(i + jump_distance)]) #stone \n t = max(t, stone)\n print(f'end of while loop: t = {t}') \n \n return t\n #what's the lowest num within that jump_distance \n #go to that stone, then look at next stones in new jump_distance\n #t becomes whatever stone we jumped to\n #if the next stone we jump to is a higher value, reassign t\n #get length of list of stones so we don't go past length\n #var assigned to len(list) and compare to index we're at \n #if index we're jumping to is higher than len of list, then we're done\n #control for indexerror with while loop?\n # ","def spotlessroomba_second_heuristic(state : SpotlessRoombaState) -> float:\n # TODO a nontrivial consistent heuristic\n \n if not state.dirty_locations:\n return 0\n \n best_start = 0 # best dirty tile to start from\n best_cost = INF # cost of the path from the above start tile\n\n for i in range(len(state.dirty_locations)):\n estimate_cost = 0\n lowest_cost = INF\n closest_dirty = 0\n dirty_locations = list(state.dirty_locations)\n current_pos = dirty_locations.pop(i)\n\n # find the shortest cost solution path from this starting tile\n while dirty_locations:\n for j in range(len(dirty_locations)):\n manhattan = abs(current_pos.row - dirty_locations[j].row) + abs(current_pos.col - dirty_locations[j].col)\n if manhattan < lowest_cost:\n lowest_cost = manhattan\n closest_dirty = j\n estimate_cost += lowest_cost\n current_pos = dirty_locations.pop(closest_dirty)\n lowest_cost = INF\n # if estimated path cost is cheaper than best path cost so far, replace best_cost and best_start\n if estimate_cost < best_cost:\n best_cost = estimate_cost\n best_start = i\n # if estimated path cost and best path cost so far are equal, tiebreak with proximity to start tile\n if estimate_cost == best_cost:\n current_pos = state.position\n dist_to_prev_best = abs(current_pos.row - state.dirty_locations[best_start].row) + abs(current_pos.col - state.dirty_locations[best_start].col)\n dist_to_i = abs(current_pos.row - state.dirty_locations[i].row) + abs(current_pos.col - state.dirty_locations[i].col)\n if dist_to_i < dist_to_prev_best:\n best_start = i\n \n\n current_pos = state.position\n # Calculate distance to the best start tile\n dist_to_start = abs(current_pos.row - state.dirty_locations[best_start].row) + abs(current_pos.col - state.dirty_locations[best_start].col)\n # Returned heuristic is the sum of distance to the start tile and estimated cost from said tile\n return dist_to_start + best_cost","def fn(i, s0, s1, c0, c1):\n if s0 > n or s1 > n: return 0 # impossible \n if i == len(balls): return int(c0 == c1)\n ans = 0 \n for x in range(balls[i]+1): \n ans += fn(i+1, s0+x, s1+balls[i]-x, c0+(x > 0), c1+(x < balls[i])) * comb(balls[i], x)\n return ans","def solution(A):\n \n cars = 0\n ones = 0\n\n for i in range(len(A), 0, -1):\n\n if A[i-1] == 1:\n ones += 1\n else:\n cars += ones\n\n return (-1 if cars > 1000000000 else cars)","def find_all_ORFs_both_strands(dna):\n \n # YOUR IMPLEMENTATION HERE","def gameOfStones(n):\n winning_start = set([2, 3, 4, 5]) # 7 we don't know who would win yet\n losing_start = set([0, 1])\n\n def n_remain(n_):\n n_next = set([n_ - x for x in [2, 3, 5] if n_ - x >= 0])\n return n_next\n\n i = 0\n while i < n + 1:\n x = n_remain(i)\n # let's build lookup table to see what each value of up to n yields as\n # far as winner under optimal play\n if i in winning_start:\n # print('Player 1 wins')\n pass\n elif i in losing_start:\n # print('Player 2 wins')\n pass\n elif len(losing_start.intersection(x)) > 0:\n # if player 1 has any option that is a losing start, he win\n print(i, 'Adding to winning start', x)\n winning_start.add(i)\n elif len(winning_start.intersection(x)) == len(x):\n # if player 1 gives player 2 only winning options, p1 loses\n print(i, 'Adding to losing start', x)\n losing_start.add(i)\n else:\n print('this should never happen')\n i += 1\n\n if n in winning_start:\n print('First')\n return 'First'\n else:\n print('Second')\n return 'Second'","def Solve(bases):\r\n n = 1\r\n while 1:\r\n n += 1\r\n done = True\r\n for b in bases:\r\n if not Happy(n, b):\r\n done = False\r\n break\r\n if done:\r\n return n","def myHeuristic3(state, problem=None):\n #canto =[(1,1), (1,2), (2,1), (2,2), (36,36), (35,36), (35,35), (36,35), (1,36),(1,35),(2,36),(2,35),(36,1),(36,2),(35,1),(35,2)]\n canto = []\n for l in range(2):\n for c in range(2):\n canto.append((l,c))\n heru = abs(state[0] - 1) + abs(state[1] - 1)\n #heru=10\n if state in canto:\n #print(\"sim\")\n heru = heru * 0.5\n return heru","def test_teleport_minimal_basis_gates(self):\n shots = 2000\n circuits = ref_algorithms.teleport_circuit()\n targets = ref_algorithms.teleport_counts(shots)\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX')\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)","def branchNBound(nationtxt, bound, scheme):\n provinces = []\n index = 0\n costs = 0\n numTransmitters = 7\n\n transmitterCosts = scheme\n nation = nationLoader(nationtxt)\n\n\n neighborCount = {}\n for province in nation:\n neighborCount.update({province:len(nation.get(province)[0])})\n\n\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\n\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\n\n for key in neighborCountSorted:\n provinces.append(key)\n #~ print provinces\n\n upperbound = bound\n #~ print bound\n #~ print bound\n\n\n\n solution = []\n\n\n counter = 0\n\n\n\n\n\n while index >= 0:\n\n\n counter += 1\n if counter % 100000000 == 0:\n print counter\n print \"Now at:\", nation\n\n\n if index == -1:\n break\n\n # Assign transmitter\n if nation[provinces[index]][1] == numTransmitters:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n else:\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\n\n # Check if costs are above upper bound\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n # Check if a neighbor has the same transmitter\n conflict = False\n for neighbor in nation[provinces[index]][0]:\n if nation[neighbor][1] == nation[provinces[index]][1]:\n conflict = True\n break\n\n if conflict:\n continue\n\n # Check if a solution is found\n if index == len(provinces) - 1:\n #~ print \"\\nSOLUTION:\"\n if costs < upperbound:\n solution = []\n solution.append(json_deep_copy(nation))\n upperbound = costs\n #~ print \"Score:\", upperbound\n #~ print nation\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n index += 1\n\n\n usedTrans = []\n fivePlus = 0\n fivePlusNoDuplicate = 0\n\n for nation in solution:\n\n one = 0\n two = 0\n three = 0\n four = 0\n five = 0\n six = 0\n seven = 0\n\n for province in nation:\n\n if nation[province][1] == 1:\n one += 1\n if nation[province][1] == 2:\n two += 1\n if nation[province][1] == 3:\n three += 1\n if nation[province][1] == 4:\n four += 1\n if nation[province][1] == 5:\n five += 1\n if nation[province][1] == 6:\n six += 1\n if nation[province][1] == 7:\n seven += 1\n\n\n if five > 0 or six > 0 or seven > 0:\n fivePlus += 1\n if transmitterCosts[3] != transmitterCosts[4]:\n fivePlusNoDuplicate += 1\n\n usedTrans.append([one, two, three, four, five, six, seven])\n\n return fivePlus, fivePlusNoDuplicate, usedTrans, upperbound, len(solution), counter\n #~ f.write(\"\\n Used Transmitters: \"+ str(one)+\" \"+ str(two)+\" \"+ str(three)+\" \"+ str(four)+\" \"+ str(five)+\" \"+ str(six)+\" \"+ str(seven)+\"\\n Cost: \"+str(upperbound)+\"\\n Number of solutions: \"+str(len(solution))+\"\\n Iterations: \"+str(counter)+\"\\n\"+\"\\n\"+\"\\n\"+\"\\n\")\n\n #~ print \"transmitter frequecies:\", one, two, three, four, five, six, seven\n #~ print \"Solutions:\", solution\n #~ print \"Cost:\", upperbound\n #~ print \"Number of solutions:\", len(solution)\n #~ print \"Iterations:\", counter","def solve(k=[]):\n if len(k) < 2:\n return 1\n min_jumps = len(k)\n for i in reversed(range(k[0])):\n if i > len(k):\n return 1\n if k[i] != 0:\n sub_jumps = solve(k[i + 1 :])\n min_jumps = min(min_jumps, sub_jumps)\n return min_jumps","def main():\n LIMIT = 600\n GOAL = 1000\n for i in range(1, LIMIT + 1):\n for j in range(1, LIMIT + 1):\n for k in range(1, LIMIT + 1):\n if i + j + k == GOAL:\n if i**2 == j**2 + k**2:\n print \"GOAL:\", (i, j, k)","def occam_razor() -> None:\r\n print(\"WARNING! Mode three activated. Time to complete may be several minutes\")\r\n temp = [] # x-y-conflicts\r\n global example\r\n backup = example.copy() # Backup so it can backtrack through solutions\r\n for x in range(shape):\r\n for y in range(shape):\r\n conflict_counter = 0\r\n for z in range(shape):\r\n if conflict_space[x, y] != 0:\r\n if conflict_space[x, y] == conflict_space[x, z] and z != y:\r\n conflict_counter += 1\r\n if conflict_space[x, y] == conflict_space[z, y] and z != x:\r\n conflict_counter += 1\r\n if conflict_counter > 0 and no_neighbour(x, y):\r\n temp.append([x, y, conflict_counter])\r\n threshold = [0, 0, 0]\r\n \"\"\"Takes an educated guess on the node in most conflict in case it's one move away from being solved\"\"\"\r\n for x in range(len(temp)):\r\n if temp[x][2] > threshold[2]:\r\n threshold = temp[x]\r\n if threshold[2] > 0:\r\n example[threshold[0], threshold[1]] = 0\r\n shade_neighbours(threshold[0], threshold[1])\r\n if not victory_checker():\r\n \"\"\"code now begins guessing\"\"\"\r\n for x in range(len(temp)):\r\n example = backup.copy()\r\n if no_neighbour(temp[x][0], temp[x][1]):\r\n example[temp[x][0], temp[x][1]] = 0\r\n else:\r\n continue\r\n progress_handler(False, True)\r\n while progress_handler(True, False):\r\n print_debug(\"itteration\")\r\n progress_handler(False, False)\r\n mark_check()\r\n if victory_checker():\r\n completion(True)\r\n if not progress_handler(True, False):\r\n special_corner()\r\n if not progress_handler(True, False):\r\n separation_crawler(True)\r\n if not progress_handler(True, False):\r\n occam_razor() # Recursive\r\n if not progress_handler(True, False):\r\n if victory_checker():\r\n completion(True)\r\n else:\r\n print(\"Searching...\")\r\n continue\r\n conflict_check()","def solve(num_wizards, num_constraints, wizards, constraints):\n\n # print(num_wizards)\n # print(num_constraints)\n # print(wizards)\n # print(constraints)\n # node_set = set(wizards)\n \n\n\n def cost(sol,num_constraints,constraints):\n constraints_satisfied = 0\n constraints_failed = []\n output_ordering_map = {k: v for v, k in enumerate(sol)}\n for c in constraints:\n\n m = output_ordering_map # Creating an alias for easy reference\n\n wiz_a = m[c[0]]\n wiz_b = m[c[1]]\n wiz_mid = m[c[2]]\n\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\n constraints_failed.append(c)\n else:\n constraints_satisfied += 1\n return num_constraints - constraints_satisfied\n\n def neighbors(sol):\n wiz1 = random.randint(0,num_wizards-1)\n wiz2 = random.randint(0,num_wizards-1)\n\n new_sol = copy.copy(sol)\n temp = new_sol[wiz1]\n new_sol[wiz1] = new_sol[wiz2]\n new_sol[wiz2] = temp\n \n return new_sol\n\n def acceptance_probability(old_cost,new_cost,T):\n exponent = (old_cost - new_cost) / T\n \n try:\n ans = math.exp(exponent)\n except OverflowError:\n ans = float('inf')\n return ans\n\n\n def anneal(solution, num_constraints, constraints):\n old_cost = 0\n new_cost = 0\n old_cost = cost(solution,num_constraints,constraints)\n T = 1.0\n T_min = 0.000001\n alpha = 0.98\n while T > T_min:\n i = 1\n while i <= 1000:\n new_solution = neighbors(solution)\n new_cost = cost(new_solution,num_constraints,constraints)\n if new_cost == 0:\n return new_solution,new_cost\n ap = acceptance_probability(old_cost, new_cost, T)\n if ap > random.random():\n solution = new_solution\n old_cost = new_cost\n i += 1\n T = T*alpha\n return solution, old_cost\n\n s = copy.copy(wizards)\n random.shuffle(s)\n ret = anneal(s,num_constraints,constraints)\n \n for i in range(10):\n if ret[1] == 0:\n break\n random.shuffle(s)\n new_ret = anneal(s,num_constraints,constraints)\n print(i)\n if new_ret[1] < ret[1]:\n ret = new_ret\n print(\"constraints failed: {0}\".format(ret[1]))\n return ret[0]","def solution(n: int = 28123) -> int:\n\n nums = range(1, n+1)\n abundant = list(filter(is_abundant, nums))\n abundant_sums = set(all_sums(abundant, n))\n fit = set(nums) - abundant_sums\n return fit","def find_non_trivial_orbit(generators: [Permutation]) -> int:\n if not generators:\n return None\n n = generators[0].n\n for P in generators:\n for element in range(n):\n if P[element] != element:\n return element","def brute_force(city_list):\n start = time.time()*1000\n shortest = exhaustive_search(city_list,6)\n stop = time.time()*1000\n print(\"Shortest tour for 6 first cities:\", tour_distance(shortest))\n print (\"Time spent on 6 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\"-\")\n \n start = time.time()*1000\n shortest = exhaustive_search(city_list,7)\n stop = time.time()*1000\n print(\"Shortest tour for 7 first cities:\", tour_distance(shortest))\n print (\"Time spent on 7 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\"-\")\n \n start = time.time()*1000\n shortest = exhaustive_search(city_list,8)\n stop = time.time()*1000\n print(\"Shortest tour for 8 first cities:\", tour_distance(shortest))\n print (\"Time spent on 8 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\"-\")\n \n start = time.time()*1000\n shortest = exhaustive_search(city_list,9)\n stop = time.time()*1000\n print(\"Shortest tour for 9 first cities:\", tour_distance(shortest))\n print (\"Time spent on 9 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\"-\")\n \n start = time.time()*1000\n shortest = exhaustive_search(city_list,10)\n stop = time.time()*1000\n print(\"Shortest tour for 10 first cities:\", tour_distance(shortest))\n print (\"Time spent on 10 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\" \")","def __checkvictory__(self,playerchar):\n\t\tvictory = False\n\t\tboardx = deepcopy(self.board)\n\t\trow = 5\n\t\tcolumn = 6\n\t\tstarburst_bag = []\n\t\tcats_game = True\n\t\tfor a in range(row+1):\n\t\t\tfor b in range(column+1):\n\t\t\t\tstarburst = []\n\t\t\t\tstarburst.append((a,b))\n\t\t\t\t\n\t\t\t\tif self.__checkplace__(a,b) is True:\n\t\t\t\t\tcats_game = False\n\t\t\t\t\tcontinue\n\t\t\t\telif self.__checkplace__(a,b) == playerchar:\n\t\t\t\t\t\n\t\t\t\t\tstarburst.append(1)\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\twhile True:\n\t\t\t\t\t\tif a-starburst[1] < 0:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif self.__checkplace__(a-starburst[1],b) == playerchar:\n\t\t\t\t\t\t\tstarburst[1] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\tstarburst.append(1)\n\t\t\t\t\t\n\t\t\t\t\twhile True:\n\t\t\t\t\t\tif a-starburst[2] < 0:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif b+starburst[2] > 6:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif self.__checkplace__(a-starburst[2],b+starburst[2])\\\n\t\t\t\t\t\t == playerchar:\n\t\t\t\t\t\t\tstarburst[2] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\tstarburst.append(1)\n\t\t\t\t\t\n\t\t\t\t\twhile True:\n\t\t\t\t\t\tif b+starburst[3] > 6:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif self.__checkplace__(a,b+starburst[3]) == playerchar:\n\t\t\t\t\t\t\tstarburst[3] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\tstarburst.append(1)\n\t\t\t\t\t\n\t\t\t\t\twhile True:\n\t\t\t\t\t\tif a+starburst[4] > 5:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif b+starburst[4] > 6:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif self.__checkplace__(a+starburst[4],b+starburst[4])\\\n\t\t\t\t\t\t== playerchar:\n\t\t\t\t\t\t\tstarburst[4] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\tstarburst_bag.append(starburst)\n\t\t\n\t\tfor starburst in starburst_bag:\n\t\t\t\n\t\t\ta = starburst[0][0]\n\t\t\tb = starburst[0][1]\n\t\t\t\n\t\t\tif starburst[1] > 3:\n\t\t\t\tvictory = True\n\t\t\t\tfor i in range(starburst[1]):\n\t\t\t\t\tboardx[a-i][b] = boardx[a-i][b].\\\n\t\t\t\t\treplace(playerchar,playerchar.upper())\n\t\t\tif starburst[2] > 3:\n\t\t\t\tvictory = True\n\t\t\t\tfor i in range(starburst[2]):\n\t\t\t\t\tboardx[a-i][b+i] = boardx[a-i][b+i].\\\n\t\t\t\t\treplace(playerchar,playerchar.upper())\n\t\t\tif starburst[3] > 3:\n\t\t\t\tvictory = True\n\t\t\t\tfor i in range(starburst[3]):\n\t\t\t\t\tboardx[a][b+i] = boardx[a][b+i].\\\n\t\t\t\t\treplace(playerchar,playerchar.upper())\n\t\t\tif starburst[4] > 3:\n\t\t\t\tvictory = True\n\t\t\t\tfor i in range(starburst[4]):\n\t\t\t\t\tboardx[a+i][b+i] = boardx[a+i][b+i].\\\n\t\t\t\t\treplace(playerchar,playerchar.upper())\n\t\t\t\n\t\tif cats_game:\n\t\t\treturn None\n\t\tif victory:\n\t\t\treturn boardx\n\t\telse:\n\t\t\treturn False","def find_santa(curr_pos=src, prev_pos='YOU', transfers=0):\n if curr_pos == dst: # base case: we found it!\n return transfers\n\n # let's try moving inward (unless that would be retracing our steps)\n parent = orbits[curr_pos]['parent']\n if parent is not None and parent != prev_pos:\n possible_route = find_santa(curr_pos=parent, prev_pos=curr_pos, transfers=transfers+1)\n if possible_route is not False:\n return possible_route\n\n # if we're still here, inward didn't work. let's move outward...\n children = [c for c in orbits[curr_pos]['children'] if c != prev_pos] # don't retrace steps\n for child in children:\n possible_route = find_santa(curr_pos=child, prev_pos=curr_pos, transfers=transfers+1)\n if possible_route is not False:\n return possible_route\n\n # at this point there are no possible routes. return false\n return False","def find():\n b = 0\n q = 0\n while b == q:\n seq = [randint(-10, 10) for _ in range(randint(15, 30))]\n b, b_at = brute_force(seq)\n q = solution(seq)\n print(seq, b, q, b_at)","def lowest_cost_search(start, successors, is_goal, action_cost):\r\n # your code here\r\n explored = set()\r\n frontier = [ [start] ]\r\n while frontier:\r\n path = frontier.pop(0)\r\n state1 = final_state(path)\r\n if is_goal(state1):\r\n return path\r\n explored.add(state1)\r\n pcost = path_cost(path)\r\n for (state, action) in successors(state1).items():\r\n if state not in explored:\r\n total_cost = pcost + action_cost(action)\r\n path2 = path [(action, total_cost), state]\r\n add_to_frontier(frontier, path2)\r\n return Fail","def McNuggets(n):\n # Your Code Here\n for c in xrange( n/20+2):\n for b in xrange( (n-20*c)/9+2):\n for a in xrange ((n-20*c-9*b)/6 +2):\n if (6*a + 9*b + 20*c) == n :\n return True\n return False","def _is_this_healthy_rDNA(self):\n if self.length < 3000:\n return 0\n mapping_state = []\n for item in self.sam_summary:\n if item[1] != '0':\n mapping_state.append(1)\n else:\n mapping_state.append(0)\n threshold = 0.8\n if sum(mapping_state)/len(mapping_state) > threshold:\n return 1\n else:\n for i in range(1, len(mapping_state) - 50):\n if sum(mapping_state[i:])/len(mapping_state[i:]) > threshold or \\\n sum(mapping_state[:-i])/len(mapping_state[:-i]) > threshold:\n healthy = 2\n return 0","def brute_force(seats):\n for seat in seats:\n if seat + 1 not in seats and seat + 2 in seats:\n return seat + 1\n\n return None","def goal_test(self, state):\n \"*** YOUR CODE HERE ***\"\n shoot_loc_arr = []\n for allowed_state in self.allowed:\n for goal_state in self.goals:\n if allowed_state[0] == goal_state[0] and allowed_state[1] < goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 0)) # Head North\n if allowed_state[0] > goal_state[0] and allowed_state[1] == goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 1)) # Head West\n if allowed_state[0] == goal_state[0] and allowed_state[1] > goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 2)) # Head South\n if allowed_state[0] < goal_state[0] and allowed_state[1] == goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 3)) # Head East\n if state in shoot_loc_arr:\n return True\n else:\n return False","def N_states_for_learner(self):\n idx_max = []\n limits = 50, 2*_math.pi, 50, 50, 50, 50, 50, 50, 50\n for idx, limit in enumerate(limits):\n test = [0 for i in xrange(len(limits))]\n check = _arange(-limit,limit,limit/1000.)\n maxi = 0\n for v in check:\n test[idx]=v\n ret = self._state_index(*test)\n maxi = max((maxi, ret[idx]))\n idx_max.append(maxi)\n\n return tuple([idx+1 for idx in idx_max])","def getSuccessors(self, state):\n\n successors = []\n top, right = self.walls.height - 2, self.walls.width - 2\n for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:\n # Add a successor state to the successor list if the action is legal\n # Here's a code snippet for figuring out whether a new position hits a wall:\n x, y = state[0]\n dx, dy = Actions.directionToVector(action)\n nextx, nexty = int(x + dx), int(y + dy)\n hitsWall = self.walls[nextx][nexty]\n \"*** YOUR CODE HERE ***\"\n \"\"\"\n La función sucesores funciona de la siguiente manera:\n * Si la acción no hace que choque con una pared, entonces...\n - Defino nextState como las coordenadas de lo que me da la acción\n - Creo una copia de la grid de true/false que tiene el estado, para así no modificar la original\n - A esta copia le actualizo la información, si el sucesor es una de las esquinas. Tengo que realizar\n esto manualmente dada la definición de mi grid de booleanos.\n - Creo una nueva variable que es una tupla en la que inserto las nuevas coordenadas y la grid actualizada\n - La añado a la lista de sucesores\n \"\"\"\n if not hitsWall:\n nextState = (nextx, nexty) # Defino la tupla que será la posición del sucesor\n nextFood = state[1].copy() # Hago una copia para así poder modificarla tranquilamente\n if nextState == (1, 1): # Manualmente miro si es alguna de las esquinas\n nextFood[1][0] = False # Si lo es, actualizo de true a false el elemento correspondiente\n if nextState == (1, top):\n nextFood[0][0] = False\n if nextState == (right, 1):\n nextFood[1][1] = False\n if nextState == (right, top):\n nextFood[0][1] = False\n nextStateFood = (nextState, nextFood) # Lo añado como tupla\n cost = 1 # Por orden del enunciado, el coste es siempre 1\n successors.append((nextStateFood, action, cost)) # Lo añado a la lista de sucesores\n self._expanded += 1\n return successors","def greedy(self, state, timestep, epsilon=0):\n\n counts = np.bincount(self.call_locs, minlength=self.num_nodes)\n # print(self.lengths)\n # print(counts)\n score = self.lengths @ counts\n action = []\n for _ in range(self.num_ambulance):\n node = np.argmin(score)\n action.append(node)\n score[node] = 99999999\n return action","def uniform_cost_search(problem):\r\n \"*** YOUR CODE HERE ***\"\r\n fringe = util.PriorityQueue()\r\n path = set()\r\n final = []\r\n acts = dict()\r\n state = problem.get_start_state()\r\n fringe.push(state, 0)\r\n\r\n while (True):\r\n state = fringe.pop()\r\n path.add(state)\r\n states = problem.get_successors(state)\r\n acts[state] = states[:]\r\n if problem.is_goal_state(state):\r\n break\r\n\r\n #states = problem.get_successors(state)\r\n # push into fringe\r\n for stat in states:\r\n if stat[0] not in path:\r\n fringe.push(stat[0], stat[1].piece.get_num_tiles()) #problem.get_cost_of_actions([stat[1]])\r\n\r\n while (True):\r\n if state == problem.get_start_state():\r\n break\r\n for key, val in acts.items():\r\n for va in val:\r\n if va[0] == state:\r\n final.append(va[1])\r\n state = key\r\n break\r\n else:\r\n continue\r\n break\r\n\r\n final.reverse()\r\n\r\n return final","def calculate_image_possibilities():\n\n # Reordering the color ramps in the palette yields 3! combinations\n palette_reorder_possibilities = 6\n\n return len(palettes) * palette_reorder_possibilities * len(grips) * len(pommels) * len(crossguards) * len(blades)","def manhattan_heuristic(state):\n man_h = 0\n size = len(state)\n for i in range (size):\n for j in range (size):\n if state[i][j] == 0:\n continue\n else:\n man_h = man_h + abs(i - int(state[i][j]/3)) + abs(j - (state[i][j])%3)\n return man_h","def nextMoveDecision(self):\n b = random.randint(1, 9) \n while (self.Occupied(b)):\n b = random.randint(1, 9) \n return b","def efficient_sol(rt=\"O(n)\"):\n def bribe_count(L): # L = line\n bribes = 0\n # from back to front\n for i in range(len(L) - 1, -1, -1):\n\n expected_index = i + 1\n # Case 1: Expected Person already in the right spot.\n if L[i] == expected_index:\n continue\n\n # Case 2: Expected Person is 1 step away. Swap.\n elif L[i - 1] == expected_index:\n L[i], L[i - 1] = L[i - 1], L[i]\n bribes += 1\n\n # Case 3: Expected person is 2 steps away. Put into proper place and other 2 up.\n elif L[i - 2] == expected_index:\n L[i - 2], L[i - 1], L[i] = L[i - 1], L[i], L[i - 2]\n bribes += 2\n else:\n return \"Too chaotic\" # Expected person is more than 2 steps away.\n return bribes\n\n test_count = int(input())\n for _ in range(test_count):\n input()\n line = list(map(int, input().split()))\n print(bribe_count(line))","def findHeuristic(self, _, __):\n popSize = 100\n retain = 0.25\n random_select = 0.1\n mutate = 0.1\n\n popList = self.populationList(popSize)\n\n solved = False\n count = 0\n while not solved:\n # evolves current\n popList = (self.evolve(popList, retain, random_select, mutate))\n# print(popList) # for troubleshooting\n for i in popList:\n if (self.fitness(i) == 0):\n print(\"solution: \", i)\n solved = True\n break\n # if plateus at a local minima, then end after 50 generations\n if count >= 50:\n if (self.fitness(i) <= 10):\n print(\"solution: \", i)\n solved = True\n break\n if solved is True:\n break\n print(\"-----------------\")\n\n # will modify mutation, random_select and retain values to help leave a\n # local minima. More randomness the longer it takes up to specific points\n if count % 3 == 0:\n if mutate < 0.2:\n mutate += 0.01\n if random_select < 0.3:\n random_select += 0.01\n count += 1\n\n return exit(0)","def solve(given: np.array) -> np.array:\n possible = np.full((9, 9, 9), True)\n mask = given > 0\n possible[mask, :] = False\n possible[mask, given[mask] - 1] = True\n\n # number of possibilities at each site, masking those already propagated\n # to avoid repetitive work. All masked == problem solved\n count = ma.array(possible.sum(axis=2), fill_value=1)\n\n # allocate upfront to as out parameter to np.equal\n # (ma.array because count is ma.array)\n where = ma.array(np.empty((9, 9), dtype=bool), fill_value=False)\n\n stack = [(possible, count)]\n while stack:\n node, count = stack.pop()\n unsolved = propagate(node, count, where)\n if unsolved == -1:\n continue\n if unsolved == 0:\n break\n # try all possibilities from cell with fewest > 1\n i, j = np.unravel_index(count.argmin(), count.shape)\n for k in np.flatnonzero(node[i, j, :]):\n node_copy, count_copy = node.copy(), count.copy()\n node_copy[i, j, :] = False\n node_copy[i, j, k] = True\n count_copy[i, j] = 1\n stack.append((node_copy, count_copy))\n\n i, j, k = node.nonzero()\n count[i, j] = k + 1\n return np.array(count)","def McNuggets(n):\n \n '''if n == 0:\n return True\n for i in (6, 9, 20):\n if n >= i and McNuggets(n - i):\n return True\n return False\n '''\n \n for a in range(0,n):\n for b in range(0,n):\n for c in range(0,n):\n if 6*a+9*b+20*c == n:\n return True\n return False","def minNumberOfSemesters(self, n: int, dependencies: List[List[int]], k: int) -> int:\n\n @lru_cache(None)\n def dp(status, take, avaliable):\n if status == target: # all taken\n return 0\n bin_take = bin(take)[2:][::-1]\n for i,v in enumerate(bin_take):\n if v == '1':\n for j in edges[i]: # the indegree number changed during recursion\n indegree[j] -= 1\n if indegree[j] == 0:\n avaliable |= (1 << j)\n status |= (1 << i)\n # print('i, status', i, v, bin(status))\n # take -= (1 << i)\n\n lst = [i for i,v in enumerate(bin(avaliable)[2:][::-1]) if v == '1']\n # print(indegree)\n # print(lst)\n if not lst:\n res = 0\n # print('lst', lst, k)\n elif len(lst) <= k:\n res = dp(status, avaliable, 0)\n else:\n res = float('inf')\n for comb in combinations(lst, k):\n # print(comb)\n t, a = 0, avaliable\n for d in comb:\n t |= (1 << d)\n a -= (1 << d)\n res = min(res, dp(status, t, a))\n for i,v in enumerate(bin_take):\n if v == '1':\n for j in edges[i]: \n indegree[j] += 1\n return 1 + res\n\n self.counts = 0\n edges = defaultdict(list)\n indegree = Counter()\n for i,j in dependencies:\n edges[i].append(j)\n indegree[j] += 1\n\n courses = set(range(1, n+1))\n start = courses - indegree.keys()\n target = 2**(n+1) - 1\n avaliable = 0\n for i in start:\n avaliable |= (1 << i)\n\n return dp(1, 0, avaliable) - 1# first dp not take courses","def test_teleport_waltz_basis_gates(self):\n shots = 2000\n circuits = ref_algorithms.teleport_circuit()\n targets = ref_algorithms.teleport_counts(shots)\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='u1,u2,u3,cx')\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)","def spotlessroomba_third_heuristic(state : SpotlessRoombaState) -> float:\n h = 0\n current_position = state.position\n dirty_locations = list(state.dirty_locations)\n partial_heuristic = INF\n closest_dirty = 0\n\n while dirty_locations:\n for i in range(len(dirty_locations)):\n manhattan = abs(current_position.row - dirty_locations[i].row) + abs(current_position.col - dirty_locations[i].col)\n if manhattan < partial_heuristic:\n partial_heuristic = manhattan\n closest_dirty = i\n h += partial_heuristic\n current_position = dirty_locations.pop(closest_dirty)\n partial_heuristic = INF\n \n return h","def part1(problem_input: Iterable[str]) -> int:\n blueprints: dict[int, tuple[RobotCost, RobotCost, RobotCost, RobotCost]] = {}\n for s in problem_input:\n num = re.search(r\"Blueprint (\\d+):\", s)[1] # type: ignore\n r_r = re.search(r\"Each ore robot costs (\\d+) ore.\", s)[1] # type: ignore\n c_r = re.search(r\"Each clay robot costs (\\d+) ore.\", s)[1] # type: ignore\n _, b_r, b_c = re.search(r\"Each obsidian robot costs (\\d+) ore and (\\d+) clay.\", s) # type: ignore\n _, g_r, g_b = re.search(r\"Each geode robot costs (\\d+) ore and (\\d+) obsidian.\", s) # type: ignore\n blueprints[int(num)] = (\n RobotCost(int(r_r), 0, 0),\n RobotCost(int(c_r), 0, 0),\n RobotCost(int(b_r), int(b_c), 0),\n RobotCost(int(g_r), 0, int(g_b)),\n )\n\n def max_geodes_harvested(blueprint: int, time: int) -> int:\n orebot_cost, claybot_cost, obsidianbot_cost, geodebot_cost = blueprints[\n blueprint\n ]\n initial_state = EconomicState(0, 0, 0, 0, 1, 0, 0, 0)\n end_states = set([initial_state])\n for t in range(time):\n print(f\"{blueprint} {t}..\")\n future_states: set[EconomicState] = set()\n for s in end_states:\n future_states.add(\n EconomicState(\n ore=s.ore + s.ore_robots,\n clay=s.clay + s.clay_robots,\n obsdian=s.obsdian + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots,\n clay_robots=s.clay_robots,\n obsdian_robots=s.obsdian_robots,\n geode_robots=s.geode_robots,\n )\n )\n if (\n geodebot_cost.ore <= s.ore\n and geodebot_cost.clay <= s.clay\n and geodebot_cost.obsdian <= s.obsdian\n ):\n future_states.add(\n EconomicState(\n ore=s.ore - geodebot_cost.ore + s.ore_robots,\n clay=s.clay - geodebot_cost.clay + s.clay_robots,\n obsdian=s.obsdian\n - geodebot_cost.obsdian\n + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots,\n clay_robots=s.clay_robots,\n obsdian_robots=s.obsdian_robots,\n geode_robots=s.geode_robots + 1,\n )\n )\n if (\n obsidianbot_cost.ore <= s.ore\n and obsidianbot_cost.clay <= s.clay\n and obsidianbot_cost.obsdian <= s.obsdian\n ):\n future_states.add(\n EconomicState(\n ore=s.ore - obsidianbot_cost.ore + s.ore_robots,\n clay=s.clay - obsidianbot_cost.clay + s.clay_robots,\n obsdian=s.obsdian\n - obsidianbot_cost.obsdian\n + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots,\n clay_robots=s.clay_robots,\n obsdian_robots=s.obsdian_robots + 1,\n geode_robots=s.geode_robots,\n )\n )\n if (\n claybot_cost.ore <= s.ore\n and claybot_cost.clay <= s.clay\n and claybot_cost.obsdian <= s.obsdian\n ):\n future_states.add(\n EconomicState(\n ore=s.ore - claybot_cost.ore + s.ore_robots,\n clay=s.clay - claybot_cost.clay + s.clay_robots,\n obsdian=s.obsdian - claybot_cost.obsdian + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots,\n clay_robots=s.clay_robots + 1,\n obsdian_robots=s.obsdian_robots,\n geode_robots=s.geode_robots,\n )\n )\n if (\n orebot_cost.ore <= s.ore\n and orebot_cost.clay <= s.clay\n and orebot_cost.obsdian <= s.obsdian\n ):\n future_states.add(\n EconomicState(\n ore=s.ore - orebot_cost.ore + s.ore_robots,\n clay=s.clay - orebot_cost.clay + s.clay_robots,\n obsdian=s.obsdian - orebot_cost.obsdian + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots + 1,\n clay_robots=s.clay_robots,\n obsdian_robots=s.obsdian_robots,\n geode_robots=s.geode_robots,\n )\n )\n end_states = future_states\n if t > 20:\n high_score = max(s.geodes for s in end_states)\n if high_score > 0:\n end_states = set(s for s in end_states if s.geodes > high_score * 0.67)\n return max(s.geodes for s in end_states)\n\n return sum(n * max_geodes_harvested(n, 24) for n in blueprints.keys())","def isSolvable(state):\n\n invCount = 0\n size = len(state)\n for i in range(0, size-1):\n for j in range(i+1, size):\n if (int(state[j]) and int(state[i]) and state[i] > state[j]):\n invCount += 1\n # return (invCount%2 == 0)\n return 1","def problem2(self, s):\n \n points = self.neighbor(100, 10, s.exhaustive_search)\n points += self.neighbor(10, 100, s.exhaustive_search)\n points += 1\n\n _testDriver.get_code(s.exhaustive_search)\n print \"\\n(Check that scipy.spatial.KDTree is not used)\"\n points *= self.grade(1)\n\n return points","def final_hop(count, final_set, last_iteration, distances):\n res = list()\n\n for j in range(1, count):\n cj0 = distances[j][0] # cost of final hop of tour\n # min-cost from 0 to j, visiting everybody once +\n index_j = bits.generate_index(final_set, count, j)\n res.append(last_iteration[index_j] + cj0)\n return min(res)","def alphabeta_search(state):\r\n \r\n '''\r\n Terminates when game.actions is empty\r\n Class Game needs the following functions:\r\n - game.result(state, a) -- successor\r\n - game.actions(state) -- possible moves\r\n - game.utility -- returns the state of the game (win/lose or tie, when game is terminal)\r\n \r\n '''\r\n #sort state.actions in increasing or decreasing based on max or min (alpha or beta)\r\n #use heuristics fn to get a value for each move (move is in format (x,y) where x and y are ints\r\n \r\n d = depthset[0] #this is the cutoff test depth value. if we exceed this value, stop\r\n cutoff_test=None\r\n sort_fn = [vitalpoint, eyeHeur]\r\n eval_fn = survivalheur \r\n #randnumheuristics \r\n player = state.to_move()\r\n prune = 0\r\n pruned = {} #this will store the depth of the prune\r\n totaldepth = [0]\r\n visited = {}\r\n heuristicInd = 0\r\n \r\n def max_value(state, alpha, beta, depth, heuristicInd):\r\n branches = len(state.actions())\r\n onbranch = 0\r\n \r\n if totaldepth[0] < depth:\r\n totaldepth[0] = depth\r\n if cutoff_test(state, depth):\r\n return eval_fn(state)\r\n v = -infinity\r\n \r\n #sort state.actions based on heuristics before calling\r\n #max wants decreasing\r\n #sorted(state.actions(), key = eval_sort, reverse = True)\r\n \r\n #sort by favorites first, returns a list of actions\r\n # for sorts in sort_fn:\r\n tempher = heuristicInd\r\n\r\n sorts = sort_fn[heuristicInd]\r\n sortedactions, heuristicInd = sorts(state)\r\n #if heuristicInd != tempher:\r\n # print 's',\r\n ''''''\r\n for a in sortedactions:\r\n if visited.get(depth) == None:\r\n visited[depth] = [a]\r\n else:\r\n visited[depth].append(a)\r\n \r\n onbranch += 1\r\n v = max(v, min_value(state.result(a),\r\n alpha, beta, depth+1, heuristicInd)) #+ vitscore.count(a)\r\n if v >= beta: #pruning happens here, but in branches\r\n if pruned.get(depth) == None:\r\n pruned[depth] = branches - onbranch\r\n else:\r\n pruned[depth] += (branches - onbranch)\r\n #print \"prune\", depth, \" \", state.actions()\r\n #state.display()\r\n return v\r\n alpha = max(alpha, v)\r\n \r\n #print depth, \" \", state.actions()\r\n #state.display()\r\n \r\n return v\r\n\r\n def min_value(state, alpha, beta, depth, heuristicInd):\r\n branches = len(state.actions())\r\n onbranch = 0\r\n \r\n if totaldepth[0] < depth:\r\n totaldepth[0] = depth\r\n if cutoff_test(state, depth):\r\n return eval_fn(state)\r\n v = infinity\r\n \r\n #sort state.actions based on heuristics before calling\r\n #min wants increasing\r\n #sorted(state.actions(), key = eval_sort)\r\n #Shayne\r\n tempher = heuristicInd\r\n sorts = sort_fn[heuristicInd]\r\n sortedactions, heuristicInd = sorts(state, 1)\r\n #if heuristicInd != tempher:\r\n # print 's',\r\n for a in sortedactions: #state.actions():\r\n onbranch += 1\r\n if visited.get(depth) == None:\r\n visited[depth] = [a]\r\n else:\r\n visited[depth].append(a)\r\n v = min(v, max_value(state.result(a),\r\n alpha, beta, depth+1, heuristicInd))\r\n if v <= alpha: #pruning happens here, but in branches\r\n if pruned.get(depth) == None:\r\n pruned[depth] = branches - onbranch\r\n else:\r\n pruned[depth] += (branches - onbranch)\r\n #print \"prune\", depth, \" \", state.actions()\r\n #state.display()\r\n return v\r\n beta = min(beta, v)\r\n #print depth, \" \", state.actions()\r\n #state.display()\r\n return v\r\n\r\n # Body of alphabeta_search starts here:\r\n #def cutoff_test and eval_fn \r\n cutoff_test = (cutoff_test or\r\n (lambda state,depth: depth>d or state.terminal_test()))\r\n eval_fn = eval_fn or (lambda state: state.utility(player))\r\n #by default, utility score is used\r\n \r\n \r\n #argmax goes through all the possible actions and \r\n # applies the alphabeta search onto all of them\r\n # and returns the move with the best score \r\n #print state.actions()\r\n heuristicInd = 0\r\n sorts = sort_fn[heuristicInd]\r\n sortedact, heuristicInd = sorts(state)\r\n abmove = argmax(sortedact,\r\n lambda a: min_value(state.result(a),\r\n -infinity, infinity, 0, heuristicInd))\r\n\r\n print 'problem,', problemno[0], ', total tree depth,', totaldepth[0]\r\n for i in range(1, len(visited)):\r\n if len(pruned) < i:\r\n pruned[i] = 0\r\n print i, \",\", len(visited[i]), \",\", pruned[i]\r\n \r\n return abmove","def day_03_b() -> int:\n instructions = read_instructions('aoc/aoc2015/input/03A.txt')\n santa_instructions = ''.join(w for i, w in enumerate(instructions) if is_odd(i))\n robo_instructions = ''.join(w for i, w in enumerate(instructions) if is_even(i))\n\n santa_houses = get_visited_houses(santa_instructions)\n robo_houses = get_visited_houses(robo_instructions)\n\n return len(merge_dicts(santa_houses, robo_houses))","def safeJourney(Alist,s,d):\n #Initialize dictionaries\n dinit = 10**6\n Edict = {} #Explored nodes\n Udict = {} #Unexplored nodes\n path = [[] for l in Alist]\n\n Alen = len(Alist) #length of Alist\n dinits = [dinit]*Alen #list of airport indexes\n Udict = dict(zip(list(range(Alen)),dinits)) #zip into dictionary\n Udict[s] = 0\n path[s] = [s]\n \n #Main search\n while len(Udict)>0:\n #Find node with min d in Udict and move to Edict\n dmin = dinit\n for n,w in Udict.items():\n if w<dmin:\n dmin=w\n nmin=n\n Edict[nmin] = Udict.pop(nmin)\n print(\"moved node\", nmin)\n\n #Update provisional distances for unexplored neighbors of nmin\n \n #for n,w in G.adj[nmin].items():\n for item in Alist[nmin]: #nminth element is a list of two element tuples (node, weight)\n n = item[0] #first elt of tuple is node/neighbour\n w = item[1] #2nd elt is density/weigh\n #for n,w in etc_______________________-\n \n if n in Edict:\n pass\n elif n in Udict:\n #dcomp = dmin + w\n dcomp = max(w,dmin) #take largest value to record most dangerous segment\n if dcomp<Udict[n]:\n print(Udict)\n Udict[n]=dcomp\n path[n] = path[nmin] + [n]\n #path[n].extend(path[nmin])\n #path[n] = path[nmin]\n \n #path[n].append(n) #n not nmin\n print(path)\n # else:\n #dcomp = dmin + w\n # dcomp = max(w,dmin)\n # Udict[n] = dcomp\n #path[n].extend(path[nmin])\n #path[n].append(nmin) \n \n if nmin == d: #if current node is destination\n return path[d],Edict[d]\n return [] #no path","def genRandTeam(nPos, totPlayers):\n # 0 1 2 3 4 5 6\n # nPos = [nFirst, nSecond, nThird, nShort, nCatcher, nOf, nDh]\n chromosome = []\n sum = 0\n count = 0\n\n\n for i in nPos: # general loop\n if count == 6: # when loop enters the nDh players it instead chooses from ALL positions five times\n for j in range(5): # to represent the 2 util positions and the 3 benches\n rNum = random.randint(0, totPlayers - 1) # random number of ANY player\n chromosome.append(rNum) # picks a random pos\n break # no more work needs to be done\n if count == 5: # this will occur before the previous loop; nOF must be iterated 3 times for 3 outfield spots\n for j in range(2):\n rNum2 = random.randint(0, i - 1)\n chromosome.append(rNum2 + sum) # nOF must be iterated 3 times for 3 outfield spots; i is on oF\n rNum3 = random.randint(0, i - 1)\n chromosome.append(rNum3 + sum)\n sum += i\n count += 1\n # first = random.randint(0,nPos[0])\n # second = random.randint(0,nPos[1])\n # third = random.randint(0,nPos[2])\n # short = random.randint(0,nPos[3])\n # catcher = random.randint(0,nPos[4])\n # of = [random.randint(0,nPos[5]), random.randint(0,nPos[5]), random.randint(0,nPos[5])] #THREE outfielders\n # rNum = [random.randint(0,6) for i in range(5)] #random numbers representing one of the nPos rosters\n # util = [random.randint(0,nPos[rNum[0]]), random.randint(0,nPos[rNum[1]])] #picks 2 random players from ANY roster\n # ben = [random.randint(0,nPos[rNum[2]]), random.randint(0,nPos[rNum[3]]), random.randint(0,nPos[rNum[4]])] # picks 3 random players form any roster\n # print first,second,third,short,catcher,of,util,ben\n # temp = Team()\n return chromosome","def spreadOutAndFindDot(self, gameState):\n # Here are some useful elements of the startState\n currentPosition = gameState.getPacmanPosition(self.index)\n foodList = gameState.getFood().asList()\n walls = gameState.getWalls()\n randomFood = []\n problem = []\n\n #problem = AnyFoodSearchProblem(gameState, self.index)\n\n # if min(manhattan(currentPosition, foodPosition) for foodPosition in food.asList()) > 10:\n # return [Directions.STOP]\n #print(\"self.targets = \", self.targets)\n if self.index == 0:\n TargetFood = ClosestFood(currentPosition, foodList)\n #self.targets.append(TargetFood)\n problem = PositionSearchProblem(gameState, 0, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\n return search.aStarSearch(problem, manhattanHeuristic)\n if self.index == 1:\n TargetFood = ClosestFood(currentPosition, foodList)\n \"\"\"\n want to find a way to avoid both agents coming up with the same target. But the below doesn't work because\n each agent has their own self.targets. How to keep a common list of targets?\n \"\"\"\n # if TargetFood in self.targets:\n # tempFoodList = foodList.copy()\n # tempFoodList.pop(tempFoodList.index(TargetFood))\n # TargetFood = ClosestFood(currentPosition, tempFoodList)\n # self.targets.append(TargetFood)\n # else:\n # self.targets.append(TargetFood)\n problem = PositionSearchProblem(gameState, 1, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\n return search.aStarSearch(problem, manhattanHeuristic)\n if self.index == 2:\n TargetFood = RandomFood(currentPosition, foodList)\n problem = PositionSearchProblem(gameState, 2, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\n return search.aStarSearch(problem, manhattanHeuristic)\n if self.index == 3:\n TargetFood = RandomFood(currentPosition, foodList)\n problem = PositionSearchProblem(gameState, 3, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\n return search.aStarSearch(problem, manhattanHeuristic)\n #return search.bfs(problem)\n\n #util.raiseNotDefined()","def sea_execution(board, position, role):\n quitt = False\n if position == 'comp':\n #print(1)\n #temporary for dumb AI\n #create and print a list of coastal, friendly regions where norse is not the ONLY one\n \n possible_region_list = []\n \n #loops through list of friendly, coastal, not just Norse regions to append to a possible_region_list\n for region in board.get_controlled_regions(role):\n #print(2)\n coastal = False\n just_norse = False\n if region.coast:\n coastal = True\n if len(region.blocks_present) == 1 and region.blocks_present[0].name.upper() == 'NORSE':\n just_norse = True\n \n if coastal and not just_norse:\n possible_region_list.append(region)\n \n \n #loops through list of friendly, coastal regions to append to a possible_final_region_list\n possible_final_region_list = []\n for region in board.get_controlled_regions(role): \n #print(3) \n if region.coast:\n possible_final_region_list.append(region)\n \n \n \n if len(possible_final_region_list) >= 2:\n #if you want to add in last-min strategy, do it here\n #random region from possible list\n england = board.regions[22]\n if england in possible_region_list:\n original_region = england\n else:\n original_region = possible_region_list[random.randint(0, len(possible_region_list) - 1)]\n #remove the original region from the possible end regions\n possible_final_region_list.remove(original_region)\n \n #possible_block_list\n #list of possible blocks to move (present in region) and not norse\n possible_block_list = []\n for block in original_region.blocks_present:\n if block.name != 'NORSE':\n possible_block_list.append(block)\n \n move_block_list = []\n blocks_moved = 0\n #print(4)\n\n while blocks_moved < 2:\n #print(5)\n block = possible_block_list[random.randint(0, len(possible_block_list)-1)]\n #if it's not already on the list,append to move_block_list\n if block not in move_block_list:\n move_block_list.append(block)\n blocks_moved+=1\n elif block in move_block_list and len(possible_block_list) == 1:\n blocks_moved+=1\n else:\n print('neither condition was met so this is an infinite loop')\n \n \n #print(6) \n new_region = possible_final_region_list[random.randint(0, len(possible_final_region_list) - 1)]\n \n for block in move_block_list:\n \n board.add_to_location(block, new_region)\n print(block.name + ' moved from ' + original_region.name + ' to ' + new_region.name)\n \n else:\n print('There are not enough friendly regions with which to play this card.')\n \n \n #add in if it's not possible\n elif position == 'opp':\n \n \n possible_region_list = []\n \n #loops through list of friendly, coastal, not just Norse regions to append to a possible_region_list\n for region in board.get_controlled_regions(role):\n coastal = False\n just_norse = False\n if region.coast:\n coastal = True\n if len(region.blocks_present) == 1 and region.blocks_present[0].name.upper() == 'NORSE':\n just_norse = True\n \n if coastal and not just_norse:\n possible_region_list.append(region)\n \n \n #loops through list of friendly, coastal regions to append to a possible_final_region_list\n possible_final_region_list = []\n for region in board.get_controlled_regions(role): \n if region.coast:\n possible_final_region_list.append(region)\n \n \n \n if len(possible_final_region_list) >= 2:\n \n print('Possible origin regions:')\n for region in possible_region_list:\n print(region.name)\n \n #user input region, check if in possible list\n valid_region = False\n while not valid_region:\n \n original_region_name = input('What region would you like to move block(s) from? Enter a name or \\'none\\'.\\n>').upper()\n \n if original_region_name != 'NONE':\n \n original_region = search.region_name_to_object(board, original_region_name)\n \n if original_region and original_region in possible_region_list:\n valid_region = True\n else:\n print('Invalid region.')\n else:\n quitt = True\n \n if not quitt:\n #remove the original region from the possible end regions\n possible_final_region_list.remove(original_region)\n \n #possible_block_list\n #list of possible blocks to move (present in region) and not norse\n possible_block_list = []\n for block in original_region.blocks_present:\n if block.name != 'NORSE':\n possible_block_list.append(block)\n \n print('Possible blocks:')\n for block in possible_block_list:\n print(block.name)\n \n \n move_block_list = []\n blocks_moved = 0\n quittt = False\n block_name = ''\n while blocks_moved < 2 and not quittt:\n if block_name != 'NONE':\n valid_block = False\n while not valid_block:\n \n \n block_name = input('Which block would you like to move? Enter a name or \\'none\\'.\\n>').upper()\n \n if block_name != 'NONE':\n \n block_to_move = search.block_name_to_object(possible_block_list, block_name)\n \n if block_to_move and block_to_move not in move_block_list:\n valid_block = True\n move_block_list.append(block_to_move)\n blocks_moved+=1\n \n elif block in move_block_list and len(possible_block_list) == 1:\n blocks_moved=1\n \n else:\n print('Invalid block.')\n continue\n else:\n valid_block = True\n if len(move_block_list) == 1:\n quittt = True\n quitt = False\n if len(move_block_list) > 0: \n print('Possible final regions:')\n for region in possible_final_region_list:\n print(region.name)\n \n #user input region, check if in possible list\n valid_region = False\n while not valid_region:\n \n new_region_name = input('What region would you like to move block(s) to? Enter a name or \\'none\\'.\\n>').upper()\n \n if new_region_name != 'NONE':\n \n new_region = search.region_name_to_object(board, new_region_name)\n \n if new_region and new_region in possible_final_region_list:\n valid_region = True\n else:\n print('Invalid region.')\n continue\n else:\n valid_region = True\n quitt = True\n \n if not quitt:\n \n for block in move_block_list:\n \n board.add_to_location(block, new_region)\n print(block.name + ' moved from ' + original_region.name + ' to ' + new_region.name)\n \n else:\n print('There are not enough friendly coastal regions with which to play this card.')","def get_high_one(self, state):\n non_zero_idxs = [-2, -3, -4]\n idx_idxs = np.random.randint(low=0, high=3, size=10)\n for idx_idx in idx_idxs:\n non_zero_idx = non_zero_idxs[idx_idx]\n if self.potential(state) + self.weights[non_zero_idx] <= self.initial_potential:\n state[non_zero_idx] += 1\n break\n return state","def find_initial_betas(self):\n if self.verbose >= 2:\n print(\"\\r{}\\rFinding initial betas\".format(' ' * 80), end='', file=sys.stderr)\n # Find ranges of states for each CRE\n Tranges = numpy.zeros((self.rna.shape[0], 2), dtype=numpy.int32)\n for i in range(self.rna_indices.shape[0] - 1):\n s = self.rna_indices[i]\n e = self.rna_indices[i + 1]\n if e - s == 0:\n continue\n s1 = self.state_indices[i]\n e1 = self.state_indices[i + 1]\n if e1 - s1 == 0:\n continue\n starts = numpy.searchsorted(self.state['end'][s1:e1],\n self.rna['TSS'][s:e] - self.initialization_dist,\n #* numpy.logical_not(self.rna['strand'][s:e]),\n side='right') + s1\n stops = numpy.searchsorted(self.state['start'][s1:e1],\n self.rna['TSS'][s:e] + self.initialization_dist,\n #* self.rna['strand'][s:e],\n side='left') + s1\n Tranges[s:e, 0] = starts\n Tranges[s:e, 1] = stops\n # Divide list across multiple processes\n tss_queue = multiprocessing.JoinableQueue()\n results_queue = multiprocessing.JoinableQueue()\n processes = []\n for i in range(self.threads):\n processes.append(multiprocessing.Process(\n target=self._assign_promoter_state, args=(tss_queue, results_queue, Tranges,\n self.initialization_dist,\n self.rng.randint(99999), True)))\n processes[-1].daemon = True\n processes[-1].start()\n step = int(self.rna_indices[-1] / max(self.threads, 1) / 4.)\n for i in range(self.rna_indices.shape[0] - 1):\n for j in range(self.rna_indices[i], self.rna_indices[i + 1], step):\n stop = min(self.rna_indices[i + 1], j + step)\n tss_queue.put((j, stop))\n for i in range(self.threads):\n tss_queue.put(None)\n # Even though there may be multiple reps for a celltype, we only find the average state proportion across reps\n Tstates = numpy.zeros((self.rna.shape[0], self.cellN, self.stateN), dtype=numpy.float32)\n finished = 0\n while finished < self.threads:\n results = results_queue.get(True)\n if results is None:\n finished += 1\n continue\n start, stop = results[:2]\n Tstates[start:stop, :, :] = results[2]\n Tstates2 = numpy.copy(Tstates)\n Tstates = Tstates[:, self.lmask, :]\n Tstates /= numpy.sum(Tstates, axis=2, keepdims=True)\n betas = numpy.linalg.lstsq(Tstates.reshape(-1, Tstates.shape[2], order='C'),\n self.rna['rna'][:, self.lmask].reshape(-1, order='C'),\n rcond=None)[0]\n self.initial_betas = betas\n if self.verbose >= 2:\n print(\"\\r{}\\r\".format(' ' * 80), end='', file=sys.stderr)","def __find_all_moves(self, tower) -> list:\r\n choice = []\r\n for height in range(1,len(tower.tower)-2):\r\n for index in range(1,4):\r\n if self.stat_brain.is_valid(height, index, tower):\r\n choice.append((height, index))\r\n \r\n r.shuffle(choice)\r\n return choice","def calculateOptimal(self) -> (list, int):\n\t\tcombinations = list(itertools.product(*self.clusters))\n\t\tmin_dist = 1000000\n\t\tmin_combination = None\n\t\tfor combination in combinations:\n\t\t\tdist = super().step(combination)\n\t\t\tif(dist < min_dist):\n\t\t\t\tmin_dist = dist\n\t\t\t\tmin_combination = combination\n\t\treturn (min_combination, min_dist)","def test_teleport_default_basis_gates(self):\n shots = 2000\n circuits = ref_algorithms.teleport_circuit()\n targets = ref_algorithms.teleport_counts(shots)\n job = execute(circuits, QasmSimulator(), shots=shots)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)","def __find_random_moves(self, tower) -> int:\r\n while True:\r\n height, index = r.randint(1, len(tower.tower)-1), r.randint(1,3)\r\n if tower.tower[height-1].blocks[index-1] == 1:\r\n return height, index","def split_candy(case):\n\n s_best_sum = 0\n\n# print case\n if len(case) <= 1:\n return \"NO\"\n\n # annotate values to protect against duplicates\n annotated_case = [ (i, x) for i,x in enumerate(case) ]\n# print annotated_case\n\n for length in range(1, len(annotated_case)):\n for s_pile in itertools.combinations(annotated_case, length):\n p_pile = set(annotated_case).difference(s_pile)\n\n # unzip\n s_pile = zip(*s_pile)[1]\n p_pile = zip(*p_pile)[1]\n\n# print s_pile, p_pile\n\n s_sum = reduce(lambda x, y: x+y, s_pile)\n s_xor = reduce(lambda x, y: x^y, s_pile)\n p_xor = reduce(lambda x, y: x^y, p_pile)\n\n# print s_pile, s_sum, s_xor, p_pile, p_xor\n if s_xor == p_xor:\n# print \"match\"\n s_best_sum = max(s_sum, s_best_sum)\n\n return s_best_sum or \"NO\"","def checkNumNeighbors():","def buyable(n: int) -> bool:\n if n in [4, 6, 25]:\n return True\n elif n < 4:\n return False\n else:\n buyability = False\n for size in [4, 6, 25]:\n buyability |= buyable(n - size)\n return buyability","def get_heurisitc_cost_stacks(element, stack_index, goal_state, unused_stacks, unused_index):\n for k,v in goal_state.items():\n if element in v:\n return (abs(stack_index - k), v.index(element))\n if stack_index in unused_stacks:\n return (0, -1)\n else:\n return (abs(unused_index - stack_index), -1)","def gene_finder(dna):\n orfs = find_all_ORFs_both_strands(dna)\n print(orfs)\n threshold = longest_ORF_noncoding(dna, 1000)\n print('threshold is', threshold)\n print('number of orfs:', len(orfs))\n aa_sequences = []\n i = 0\n while i < len(orfs):\n print(len(orfs[i]))\n if len(orfs[i]) > threshold:\n print('if')\n aa_sequences += [coding_strand_to_AA(orfs[i])]\n i += 1\n print(aa_sequences)","def four_stools_hanoi(n, first_stool, second_stool, third_stool, fourth_stool):\n if n == 1:\n return [(first_stool, fourth_stool)]\n else:\n i = find_i(n)\n a = four_stools_hanoi(n - i, first_stool, third_stool, fourth_stool,\n second_stool)\n b = three_stools_hanoi(i, first_stool, third_stool, fourth_stool)\n c = four_stools_hanoi(n - i, second_stool, third_stool, first_stool,\n fourth_stool)\n return a + b + c","def find_all_ORFs_oneframe(dna):","def _check_sonar_obstacles(self):\n # TODO: what's a good number?\n BLOCKED_THRESHOLD = 0.7\n\n rate = rospy.Rate(10) # 10 hz\n count = 10\n left = 0\n center = 0\n right = 0\n\n for i in range(count):\n obstacle = self.swarmie.get_obstacle_condition()\n\n if obstacle & Obstacle.SONAR_LEFT == Obstacle.SONAR_LEFT:\n left += 1\n if (obstacle & Obstacle.SONAR_CENTER ==\n Obstacle.SONAR_CENTER):\n center += 1\n if obstacle & Obstacle.SONAR_RIGHT == Obstacle.SONAR_RIGHT:\n right += 1\n\n rate.sleep()\n\n left_blocked = left / count > BLOCKED_THRESHOLD\n center_blocked = center / count > BLOCKED_THRESHOLD\n right_blocked = right / count > BLOCKED_THRESHOLD\n\n return left_blocked, center_blocked, right_blocked","def findAstromCorrs(self):\n self.logfile.write(\"Entered findAstromCorrs - will run: \"+\\\n \"makeGSCcat(), makeObjcats(), doMatching().\")\n\n if self.makeGSCcat() != 0:\n return -1\n if self.makeObjcats()!= 0:\n return -1\n if self.doMatching() != 0:\n # here we want to remake the GSCcat using a \"chopSpur\" flag,\n # if the cat has a goodly number of objects\n if(self.Ncull >= 10):\n print \"Retrying matchup with only GSC objs detected in 2 bands...\"\n self.logfile.write(\"Retrying matchup with only GSC objs detected in 2 bands...\")\n if self.makeGSCcat(chopSpur=1) != 0:\n return -1\n if self.makeObjcats()!= 0:\n return -1\n if self.doMatching() != 0:\n return -1\n\n return 0","def find_best_k(data, anots, neibhours_range):\r\n \r\n best_k = 0\r\n best_acc = 0\r\n for n_neighbors in neibhours_range:\r\n accur = iterate_over_chanels(data, anots, n_neighbors)\r\n mean_acc = accur.mean()\r\n if mean_acc > best_acc:\r\n best_acc = mean_acc\r\n best_k = n_neighbors\r\n return best_k","def count_ways(n):\n if n < 0:\n return 0\n elif n == 0:\n return 1\n else:\n total = 0\n for i in range(1, min(n, 3) + 1):\n total += count_ways(n - i)\n return total","def spawn_ok(game):\n me = game.me\n shipyard_cell = game.game_map[me.shipyard]\n\n # % turns above mining rate to dropoff the halite, will typically be about 2?\n mining_over_head = 2\n ship_count = len(me.get_ships())\n\n #\n # absolute constraints (order can be important)\n #\n\n if ship_count >= MAX_SHIPS:\n if DEBUG & (DEBUG_GAME): logging.info(\"Game - Spawn denied. MAX ships reached\".format())\n return False\n\n if me.halite_amount < constants.SHIP_COST:\n if DEBUG & (DEBUG_GAME): logging.info(\"Game - Spawn denied. Insufficient halite\".format())\n return False\n\n #\n # conditional constraints\n #\n\n logging.debug(\"shipyard_cell.is_occupied: {}\".format(shipyard_cell.is_occupied))\n if shipyard_cell.is_occupied:\n logging.debug(\"shipyard_cell.ship.owner == me.id: {}\".format(shipyard_cell.ship.owner == me.id))\n\n # watch for collisions with owner only, note this will be 1 turn behind\n occupied_cells = []\n if shipyard_cell.is_occupied and shipyard_cell.ship.owner == me.id:\n occupied_cells.append(shipyard_cell.position)\n\n logging.debug(\"oc1: {}\".format(occupied_cells))\n\n # entry lane are N/S\n n_cell = shipyard_cell.position.directional_offset(Direction.North)\n s_cell = shipyard_cell.position.directional_offset(Direction.South)\n e_cell = shipyard_cell.position.directional_offset(Direction.East)\n w_cell = shipyard_cell.position.directional_offset(Direction.West)\n for pos in [n_cell, s_cell, e_cell, w_cell]:\n if game.game_map[pos].is_occupied:\n occupied_cells.append(pos)\n\n logging.debug(\"oc2: {}\".format(occupied_cells))\n\n # need to keep track of ships docking instead, a ship in an adjacent cell could be leaving\n if occupied_cells:\n if DEBUG & (DEBUG_GAME): logging.info(\"Game - Spawn denied. Occupied cells: {}\".format(occupied_cells))\n return False\n\n return True","def solution(self) -> State:","def in_bomb_range(self, game_state: dict):\n is_in_bomb_range = False\n agent_position = game_state['self'][3]\n agent_position = list(agent_position)\n\n for bomb in game_state['bombs']:\n if agent_position == list(bomb[0]):\n is_in_bomb_range = True\n\n for i in range(3):\n agent_search = copy.copy(agent_position)\n if agent_position[0] - i - 1 >= 0:\n agent_search[0] = agent_position[0] - i - 1\n if agent_search == list(bomb[0]):\n is_in_bomb_range = True\n\n for i in range(3):\n agent_search = copy.copy(agent_position)\n if agent_position[0] + i + 1 <= 16:\n agent_search[0] = agent_position[0] + i + 1\n if agent_search == list(bomb[0]):\n is_in_bomb_range = True\n\n for i in range(3):\n agent_search = copy.copy(agent_position)\n if agent_position[1] - i - 1 >= 0:\n agent_search[1] = agent_position[1] - i - 1\n if agent_search == list(bomb[0]):\n is_in_bomb_range = True\n\n for i in range(3):\n agent_search = copy.copy(agent_position)\n if agent_position[1] + i + 1 <= 16:\n agent_search[1] = agent_position[1] + i + 1\n if agent_search == list(bomb[0]):\n is_in_bomb_range = True\n\n # check if a stone wall is between the agent an the bomb\n if is_in_bomb_range:\n if agent_position[0] == list(bomb[0])[0]:\n if agent_position[1] < list(bomb[0])[1]:\n for i in range(agent_position[1], list(bomb[0])[1]):\n if game_state['field'][agent_position[0]][i] == -1:\n is_in_bomb_range = False\n else:\n for i in range(list(bomb[0])[1], agent_position[1]):\n if game_state['field'][agent_position[0]][i] == -1:\n is_in_bomb_range = False\n elif agent_position[1] == list(bomb[0])[1]:\n if agent_position[0] < list(bomb[0])[0]:\n for i in range(agent_position[0], list(bomb[0])[0]):\n if game_state['field'][i][agent_position[1]] == -1:\n is_in_bomb_range = False\n else:\n for i in range(list(bomb[0])[0], agent_position[0]):\n if game_state['field'][i][agent_position[1]] == -1:\n is_in_bomb_range = False\n\n return is_in_bomb_range","def part2(problem_input: Iterable[str]) -> int:\n\n blueprints: dict[int, tuple[RobotCost, RobotCost, RobotCost, RobotCost]] = {}\n for s in problem_input:\n num = re.search(r\"Blueprint (\\d+):\", s)[1] # type: ignore\n r_r = re.search(r\"Each ore robot costs (\\d+) ore.\", s)[1] # type: ignore\n c_r = re.search(r\"Each clay robot costs (\\d+) ore.\", s)[1] # type: ignore\n _, b_r, b_c = re.search(r\"Each obsidian robot costs (\\d+) ore and (\\d+) clay.\", s) # type: ignore\n _, g_r, g_b = re.search(r\"Each geode robot costs (\\d+) ore and (\\d+) obsidian.\", s) # type: ignore\n blueprints[int(num)] = (\n RobotCost(int(r_r), 0, 0),\n RobotCost(int(c_r), 0, 0),\n RobotCost(int(b_r), int(b_c), 0),\n RobotCost(int(g_r), 0, int(g_b)),\n )\n\n def max_geodes_harvested(blueprint: int, time: int) -> int:\n orebot_cost, claybot_cost, obsidianbot_cost, geodebot_cost = blueprints[\n blueprint\n ]\n initial_state = EconomicState(0, 0, 0, 0, 1, 0, 0, 0)\n end_states = set([initial_state])\n for t in range(time):\n print(f\"{blueprint} {t}..\")\n future_states: set[EconomicState] = set()\n for s in end_states:\n future_states.add(\n EconomicState(\n ore=s.ore + s.ore_robots,\n clay=s.clay + s.clay_robots,\n obsdian=s.obsdian + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots,\n clay_robots=s.clay_robots,\n obsdian_robots=s.obsdian_robots,\n geode_robots=s.geode_robots,\n )\n )\n if (\n geodebot_cost.ore <= s.ore\n and geodebot_cost.clay <= s.clay\n and geodebot_cost.obsdian <= s.obsdian\n ):\n future_states.add(\n EconomicState(\n ore=s.ore - geodebot_cost.ore + s.ore_robots,\n clay=s.clay - geodebot_cost.clay + s.clay_robots,\n obsdian=s.obsdian\n - geodebot_cost.obsdian\n + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots,\n clay_robots=s.clay_robots,\n obsdian_robots=s.obsdian_robots,\n geode_robots=s.geode_robots + 1,\n )\n )\n if (\n obsidianbot_cost.ore <= s.ore\n and obsidianbot_cost.clay <= s.clay\n and obsidianbot_cost.obsdian <= s.obsdian\n ):\n future_states.add(\n EconomicState(\n ore=s.ore - obsidianbot_cost.ore + s.ore_robots,\n clay=s.clay - obsidianbot_cost.clay + s.clay_robots,\n obsdian=s.obsdian\n - obsidianbot_cost.obsdian\n + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots,\n clay_robots=s.clay_robots,\n obsdian_robots=s.obsdian_robots + 1,\n geode_robots=s.geode_robots,\n )\n )\n if (\n claybot_cost.ore <= s.ore\n and claybot_cost.clay <= s.clay\n and claybot_cost.obsdian <= s.obsdian\n ):\n future_states.add(\n EconomicState(\n ore=s.ore - claybot_cost.ore + s.ore_robots,\n clay=s.clay - claybot_cost.clay + s.clay_robots,\n obsdian=s.obsdian - claybot_cost.obsdian + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots,\n clay_robots=s.clay_robots + 1,\n obsdian_robots=s.obsdian_robots,\n geode_robots=s.geode_robots,\n )\n )\n if (\n orebot_cost.ore <= s.ore\n and orebot_cost.clay <= s.clay\n and orebot_cost.obsdian <= s.obsdian\n ):\n future_states.add(\n EconomicState(\n ore=s.ore - orebot_cost.ore + s.ore_robots,\n clay=s.clay - orebot_cost.clay + s.clay_robots,\n obsdian=s.obsdian - orebot_cost.obsdian + s.obsdian_robots,\n geodes=s.geodes + s.geode_robots,\n ore_robots=s.ore_robots + 1,\n clay_robots=s.clay_robots,\n obsdian_robots=s.obsdian_robots,\n geode_robots=s.geode_robots,\n )\n )\n end_states = future_states\n if t >= 25:\n high_score = max(s.geodes for s in end_states)\n if high_score > 0:\n end_states = set(s for s in end_states if s.geodes > high_score * 0.67)\n g = max(s.geodes for s in end_states)\n print(f\"{blueprint} >>>{g}<<<\")\n return g\n\n return prod(max_geodes_harvested(n, 32) for n in [1,2,3])","def get_n_best(self):\n pass","def find_all_ORFs(dna):\n \n # YOUR IMPLEMENTATION HERE","def all_valid(self, tower) -> int:\r\n count = 0\r\n for layer in range(1, len(tower.tower)):\r\n for index in range(1, 4):\r\n if self.is_valid(layer, index, tower):\r\n count += 1\r\n \r\n return count","def findIslands(self):\n\n # First lets find the shores.\n shoreList = self.findShores()\n\n # Initialize Blank Values.\n N, S, E, W = (None for i in range(4))\n\n # Next, we find all the furthest extremities among all shore lists.\n # In theory, the only extremities that can occur for shorelines that\n # Don't belong to the main pond body are along the map edge.\n for index, shore in enumerate(shoreList):\n extremityHash = shore.findExtremities()\n if index == 0:\n N, S, E, W = ([shore] for i in range(4))\n continue\n if extremityHash['N'][0].x < N[0].findExtremities()['N'][0].x:\n N = [shore]\n elif extremityHash['N'][0].x == N[0].findExtremities()['N'][0].x:\n N.append(shore)\n if extremityHash['S'][0].x > S[0].findExtremities()['S'][0].x:\n S = [shore]\n elif extremityHash['S'][0].x == S[0].findExtremities()['S'][0].x:\n S.append(shore)\n if extremityHash['E'][0].y > E[0].findExtremities()['E'][0].y:\n E = [shore]\n elif extremityHash['E'][0].y == E[0].findExtremities()['E'][0].y:\n E.append(shore)\n if extremityHash['W'][0].y < W[0].findExtremities()['W'][0].y:\n W = [shore]\n elif extremityHash['W'][0].y == W[0].findExtremities()['W'][0].y:\n W.append(shore)\n\n # Now, lets flatten the list of cardinal extremities\n flatList = [val for sublist in [N, S, E, W] for val in sublist]\n counter = Counter(flatList)\n\n # In theory, the main pond shore should have the most extremities\n probablyPond = counter.most_common(1)\n\n # Wow, what a piece of crap. I feel ashamed of the next 6 lines.\n if probablyPond[0][0] < 4:\n raise Exception(\"Largest Pond does not have 4 max points.\"\n \" Something is horribly Wrong.\")\n if len(probablyPond) != 1:\n raise Exception(\"Equal number of extremities in pond?\"\n \" How can that be?\")\n\n probablyPond = probablyPond[0][0]\n\n # Find any map edges and add them to the Plain Blob Object mapEdge.\n self.mapEdge = self.findMapEdge()\n\n # Well, this probably isn't an island, so drop it from the list.\n shoreList.remove(probablyPond)\n\n # Find any map edges for the island, and create Island Objects.\n islands = list()\n for island in shoreList:\n islands.append(Island(island.points,\n self.analyzeData,\n self.elevation))\n return islands","def branching_factor(data, loc):\n\n return 20","def test_specific_case(self):\n fasta_file = os.path.normpath(get_fasta_file('T00759-tiny.fa'))\n seed = 'AAAACCCA'\n W = len(seed)\n num_sites = 4\n self.options.max_num_sites = num_sites\n self.options.min_num_sites = num_sites\n \n #\n # Load sequences and build index\n #\n algorithm = stempy.Algorithm(self.options)\n algorithm._initialise(fasta_file)\n data = algorithm.input_sequences.data\n\n model = algorithm.create_model_of_input(W)\n model.bs.seed(seed, True)\n model.set_lambda_for_sites(data.num_sequences)\n\n # look for best W-mers under model\n best_w_mer_finder = stempy.create_best_w_mer_finder(data, model, num_sites)\n best_w_mer_finder()\n if len(best_w_mer_finder.best_w_mers) < num_sites:\n if len(best_w_mer_finder.best_w_mers) != model.num_W_mers:\n raise ValueError('Did not find enough W-mers')\n \n # We want to get these W-mers\n # \n # 2011-08-09 10:11:32,846 - INFO - Z=8.00e-02; pos= 313 +; AAAACCCA; AAAACCCA\n # 2011-08-09 10:11:32,846 - INFO - Z=4.37e-02; pos= 668 -; TGAGTTTT; AAAACTCA\n # 2011-08-09 10:11:32,846 - INFO - Z=1.37e-02; pos= 710 -; TGGTTTTC; GAAAACCA\n # 2011-08-09 10:11:32,846 - INFO - Z=1.37e-02; pos= 681 -; TGGTTCTT; AAGAACCA\n # \n for wmer, (global_pos, rev_comp) in zip(best_w_mer_finder.best_w_mers, [(313, False), (668, True), (710, True), (681, True)]):\n if wmer.global_pos != global_pos and wmer.Z < model.calculate_Z(global_pos, rev_comp):\n raise ValueError('Got wrong W-mers')","def _max_bits_used_in_function_in_round():\n word_size = 16\n bits_occupied = [word_size] * len(cost_functions)\n for (pa, pb) in all_possible_pairs:\n for i in range(len(cost_functions)):\n max_sum_of_cost = num_pairings_in_round * \\\n cost_functions[i](pa, pb)\n while (max_sum_of_cost >= 2**bits_occupied[i]):\n bits_occupied[i] *= 2\n bits_occupied = [2*b for b in bits_occupied] # Paranoia\n for b in bits_occupied:\n assert(b % word_size == 0)\n return max(bits_occupied)","def lowest_cost_search(start, successors, is_goal, action_cost):\r\n Fail = []\r\n explored = set() # set of states we have visited\r\n frontier = [[start]] # ordered list of paths we have blazed\r\n while frontier:\r\n path = frontier.pop(0)\r\n state1 = final_state(path)\r\n if is_goal(state1):\r\n return path\r\n explored.add(state1)\r\n pcost = path_cost(path)\r\n for (state, action) in successors(state1).items():\r\n if state not in explored:\r\n total_cost = pcost + action_cost(action)\r\n path2 = path + [(action, total_cost), state]\r\n add_to_frontier(frontier, path2)\r\n return Fail","def possible_rolls(D1,n):\n possibilities = []\n for D2 in range(1,7):\n for D3 in range(1,7):\n if D1+D2+D3 == n:\n possibilities.append((D1,D2,D3))\n return possibilities","def correct_barcode_bitwise(query_seq, seq_possibilities,\r\n nt_to_bits=DEFAULT_GOLAY_NT_TO_BITS):\r\n if nt_to_bits is None:\r\n nt_to_bits = DEFAULT_NT_TO_BITS\r\n dists = []\r\n query_seq_bits = seq_to_bits(query_seq, nt_to_bits)\r\n for seq in seq_possibilities:\r\n possible_seq_bits = seq_to_bits(seq, nt_to_bits)\r\n dists.append(hamming_dist(query_seq_bits, possible_seq_bits))\r\n min_dist = min(dists)\r\n number_mins = dists.count(min_dist)\r\n if number_mins > 1:\r\n return None, min_dist\r\n else:\r\n best_hit = seq_possibilities[dists.index(min_dist)]\r\n return best_hit, min_dist","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n path_to_point = {}\n cost_to_point = {}\n\n # Get the start node\n start_node = problem.getStartState()\n fringe_node = [start_node]\n path_to_point[start_node] = []\n cost_to_point[start_node] = problem.getCostOfActions(path_to_point[start_node])\n\n goal_found = False\n\n while(not goal_found):\n #for i in range(100): \n nodes_to_expand = set()\n # get max value node in the fringe node\n min_val = float(\"inf\")\n for one_node in fringe_node:\n # Compute the cost to reach a node\n if cost_to_point[one_node] < min_val:\n min_val = cost_to_point[one_node]\n \n for one_node in fringe_node:\n # Compute the cost to reach a node\n if cost_to_point[one_node] == min_val:\n nodes_to_expand.add(one_node)\n fringe_node.remove(one_node)\n\n # Expand the fringe node \n for one_node in nodes_to_expand:\n path_to_parent = path_to_point[one_node]\n for nxt_node in problem.getSuccessors(one_node):\n pos = nxt_node[0]\n mv = nxt_node[1]\n # check if point already present in path to point\n prev_cost = float(\"inf\")\n if pos in cost_to_point:\n prev_cost = cost_to_point[pos]\n new_path = path_to_parent + [mv]\n if prev_cost > problem.getCostOfActions(new_path):\n path_to_point[pos] = new_path\n cost_to_point[pos] = problem.getCostOfActions(new_path)\n fringe_node.append(pos)\n\n # Check if destination is reached in the fringe node\n for one_node in fringe_node:\n if problem.isGoalState(one_node):\n final_node = one_node\n goal_found = True\n break\n \n #print(len(fringe_node))\n print(final_node)\n print(path_to_point[final_node])\n return path_to_point[final_node] \n\n util.raiseNotDefined()","def gene_finder(dna, threshold):\n finder = []\n twoStrands = find_all_ORFs_both_strands(dna) #this calls the function that finds the compliment of dna and finds all ORFs \n print twoStrands \n for k in range(len(twoStrands)): #go through the list \"twoStrands\"\n if twoStrands[k]>threshold: #if the length of \n print twoStrands[k]\n print len(twoStrands[k])\n finder.append(twoStrands[k])\n return finder","def test_possibilites(self):\n self.assertEqual(self.RNA(\"\").possibilities(), 1)\n self.assertEqual(self.RNA(\"ACGUgcaucagUCGuGCAU\").possibilities(), 1)\n self.assertEqual(self.RNA(\"N\").possibilities(), 4)\n self.assertEqual(self.RNA(\"R\").possibilities(), 2)\n self.assertEqual(self.RNA(\"H\").possibilities(), 3)\n self.assertEqual(self.RNA(\"nRh\").possibilities(), 24)\n self.assertEqual(\n self.RNA(\"AUGCnGUCAg-aurGauc--gauhcgauacgws\").possibilities(), 96\n )","def lowest_cost_search(start, successors, is_goal, action_cost):\n explored = set()\n frontier = [ [start] ]\n if is_goal(start):\n return frontier[0]\n while frontier:\n path = frontier.pop(0)\n state1 = final_state(path)\n if is_goal(state1):\n return path\n explored.add(state1)\n pcost = path_cost(path)\n for (state, action) in successors(state1).items():\n if state not in explored:\n total_cost = pcost +action_cost(action)\n path2 = path + [(action, total_cost), state]\n frontier.append(path2)\n add_to_frontier(frontier, path2)\n return Fail","def test_solvation_with_additional_ions(self):\n waters = np.random.randint(1000, 10000)\n cations = ['LI', 'Na+', 'K+', 'RB', 'CS']\n anions = ['F', 'Cl-', 'BR', 'IOD']\n n_cations = np.random.randint(1, 10)\n n_anions = np.random.randint(1, 10)\n random_cation = random.choice(cations)\n random_anion = random.choice(anions)\n log.debug('Trying {} waters with additional ions...'.format(waters))\n solvate(tleapfile='./cb6-but/tleap.in', pdbfile='cb6-but.pdb',\n bufferwater=waters, neutralize=0,\n addions=[random_cation, n_cations, random_anion, n_anions])\n # These should come in the RESIDUE_LABEL region of the prmtop and be before all the water.\n cation_number = sp.check_output([\"grep -A 99 RESIDUE_LABEL ./cb6-but/solvated.prmtop | \" +\n \"grep -oh '{} ' | wc -w\".format(random_cation)],\n shell=True)\n anion_number = sp.check_output([\"grep -A 99 RESIDUE_LABEL ./cb6-but/solvated.prmtop | \" +\n \"grep -oh '{} ' | wc -w\".format(random_anion)],\n shell=True)\n # Have to think about what to do here...\n # log.debug('Expecting...')\n # log.debug('cation = {}\\tn_cations={}'.format(random_cation, n_cations))\n # log.debug('anion = {}\\t n_anions={}'.format(random_anion, n_anions))\n # log.debug('Found...')\n # log.debug(' n_cations={}'.format(cation_number))\n # log.debug(' n_anions={}'.format(anion_number))\n\n self.assertTrue(int(cation_number) == n_cations and int(anion_number) == n_anions)","def numberOfBoomerangsSlow(self, points):\n\n def is_boomerang(i, j, k):\n dist_a = pow(j[0] - i[0], 2) + pow(j[1] - i[1], 2)\n dist_b = pow(k[0] - i[0], 2) + pow(k[1] - i[1], 2)\n return dist_a == dist_b\n\n total = 0\n for i in points:\n for j in points:\n for k in points:\n if i != j and j != k and is_boomerang(i, j, k):\n total += 1\n return total","def canto_oposto_6(tab, jog):\r\n jog*=-1\r\n if obter_linha(tab,1)[0]==jog and eh_posicao_livre(tab,9):\r\n return 9\r\n if obter_linha(tab,1)[2]==jog and eh_posicao_livre(tab,7):\r\n return 7\r\n if obter_linha(tab,3)[0]==jog and eh_posicao_livre(tab,3):\r\n return 3\r\n if obter_linha(tab,3)[2]==jog and eh_posicao_livre(tab,1):\r\n return 1","def _strength5(self, tournoi, best=5):\n L = self.sorted_team_list()\n s = 0\n for i,e in enumerate(L):\n if tournoi in e._positions:\n s += 1\n if s == best:\n return i+1"],"string":"[\n \"def spotlessroomba_first_heuristic(state : SpotlessRoombaState) -> float:\\n # TODO a nontrivial admissible heuristic\\n return len(state.dirty_locations)\",\n \"def challenge1(self):\\n self.parse_input()\\n\\n # Find strongest nanobot\\n strongest = max(self.nanobots, key=lambda n: n.r)\\n\\n # Find all in range of this\\n num_in_range = 0\\n for nanobot in self.nanobots:\\n if manhattan_dist(nanobot.coord, strongest.coord) <= strongest.r:\\n num_in_range += 1\\n\\n print(f\\\"{num_in_range} nanobots are in range of strongest\\\")\",\n \"def bridge_problem3(here):\\r\\n\\r\\n def all_over(state):\\r\\n here, _ = state\\r\\n return not here or here == set([\\\"light\\\"])\\r\\n\\r\\n start = (frozenset(here) | frozenset([\\\"light\\\"]), frozenset())\\r\\n return lowest_cost_search(start, bsuccessors2, all_over, bcost)\",\n \"def shortest_tips(neuron):\\n (branch_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 2)\\n (endpoint_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 0)\\n selected_index = np.union1d(endpoint_index + 1,\\n branch_index + 1)\\n selected_index = np.append(0, selected_index)\",\n \"def obstacle_count(self):\\n self.wide_scan()\\n found_something = False\\n counter = 0\\n for distance in self.scan:\\n if distance and distance < 200 and not found_something:\\n found_something = True\\n counter += 1\\n print(\\\"Object # %d found, I think\\\" % counter)\\n if distance and distance > 200 and found_something:\\n found_something = False\\n print(\\\"\\\\n----I SEE %d OBJECTS----\\\\n\\\" % counter)\",\n \"def brute_force_search_solution():\\n return len(coin_search(TOTAL, COINS))\",\n \"def minimum_spanning_arborescence(sol):\",\n \"def count_stair_ways(n):\\n if n == 1:\\n return 1\\n if n == 2:\\n return 2\\n return count_stair_ways(n - 1) + count_stair_ways(n - 2)\",\n \"def large_neighborhood_search(facilities: list, towns: list, hazards: list, max_iteration: int = 50, max_improvement: int = 10) -> tuple:\\r\\n\\r\\n # counters\\r\\n max_attempts_per_swappable_facility = 10\\r\\n attempts_per_swappable_facility = 0\\r\\n improvements = 0\\r\\n iterations = 0\\r\\n\\r\\n # list of the opened facilities\\r\\n solutions = list(filter(lambda o_facility: o_facility.is_open, facilities.copy()))\\r\\n\\r\\n while True:\\r\\n\\r\\n # list of the closed facilities\\r\\n neighborhood = list(filter(lambda c_facility: not c_facility.is_open, facilities.copy()))\\r\\n\\r\\n # get the town with the maximum hazard perceived\\r\\n max_hazard_town, max_hazard = get_town_with_max_hazard(facilities, towns, hazards)\\r\\n\\r\\n # get a random opened facility to close\\r\\n swappable_facility = random.choice(solutions)\\r\\n\\r\\n while True:\\r\\n # get a random closed facility to test\\r\\n test_facility = random.choice(neighborhood)\\r\\n\\r\\n # check capacity constraint (ADMISSIBILITY)\\r\\n if test_facility.capacity >= swappable_facility.capacity:\\r\\n # destroy & repair the solution\\r\\n swappable_facility.is_open = False\\r\\n test_facility.is_open = True\\r\\n\\r\\n # calculate the new max hazard and the respective town\\r\\n new_max_hazard_town, new_max_hazard = get_town_with_max_hazard(facilities, towns, hazards)\\r\\n\\r\\n # check if the new max hazard is an improvement (SOLUTION)\\r\\n if new_max_hazard < max_hazard:\\r\\n # reassign the chosen facility to the towns whose were associated with the swappable_facility\\r\\n for town in towns:\\r\\n if town.facility == swappable_facility:\\r\\n town.facility = test_facility\\r\\n\\r\\n # reset the attempts per town counter because now there is a new solution to iterate on\\r\\n improvements += 1\\r\\n\\r\\n # rebuild the solution\\r\\n solutions = list(filter(lambda o_facility: o_facility.is_open, facilities.copy()))\\r\\n\\r\\n # exit the loop because a solution was found\\r\\n break\\r\\n\\r\\n else:\\r\\n # restore of the current solution's data structures\\r\\n swappable_facility.is_open = True\\r\\n test_facility.is_open = False\\r\\n\\r\\n # skip the chosen facility\\r\\n neighborhood.pop(neighborhood.index(test_facility))\\r\\n\\r\\n else:\\r\\n # skip the chosen facility\\r\\n neighborhood.pop(neighborhood.index(test_facility))\\r\\n\\r\\n # increment the counter for swappable facility attempts to swap, then check the limit and maybe break\\r\\n attempts_per_swappable_facility += 1\\r\\n # forbid the current swappable facility to be taken in a count for the next iteration\\r\\n if len(neighborhood) == 0 or attempts_per_swappable_facility == max_attempts_per_swappable_facility:\\r\\n solutions.pop(solutions.index(swappable_facility))\\r\\n break\\r\\n\\r\\n # if there are no more facilities in solution to be taken in account, exit the loop\\r\\n if len(solutions) == 0:\\r\\n break\\r\\n\\r\\n # check the number of improvement\\r\\n if improvements == max_improvement:\\r\\n break\\r\\n\\r\\n iterations += 1\\r\\n # check the number of iteration\\r\\n if iterations == max_iteration:\\r\\n break\\r\\n\\r\\n return iterations, improvements\",\n \"def sky_orbits(test=True):\\n \\n t = Table.read('/home/ana/data/baumgardt_positions.fits')\\n \\n ind_disterr = ~np.isfinite(t['e_Rsun'])\\n t['e_Rsun'][ind_disterr] = 0.1 * t['Rsun'][ind_disterr]\\n e_max = np.nanmax(t['e_Rsun'][~ind_disterr])\\n ind_cap = t['e_Rsun']>e_max\\n t['e_Rsun'][ind_cap] = e_max\\n \\n clusters = ['NGC 3201', 'NGC 4590', 'NGC 5824', 'NGC 5272', 'NGC 5139', 'NGC 5024']\\n #clusters = ['NGC 5824', 'NGC 5024']\\n N = len(clusters)\\n \\n match = dict()\\n match['NGC 3201'] = dict(streams=['gjoll'], direction=[-1], nstep=[35], gc_label='NGC\\\\n3201', gcra_off=0*u.deg, gcdec_off=-13*u.deg, gcl_off=0*u.deg, gcb_off=-13*u.deg, stream_label=['$Gj\\\\\\\\\\\\\\\" oll$'], stream_ra=[-156*u.deg], stream_dec=[-4.5*u.deg], eq_angle=[-45*u.deg], stream_l=[-148*u.deg], stream_b=[-33*u.deg], gal_angle=[22*u.deg])\\n \\n match['NGC 4590'] = dict(streams=['fjorm'], direction=[1], nstep=[100], gc_label='NGC\\\\n4590', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=-13*u.deg, gcb_off=-10*u.deg, stream_label=['$Fj\\\\\\\\\\\\\\\" orm$'], stream_ra=[-22*u.deg], stream_dec=[66*u.deg], eq_angle=[35*u.deg], stream_l=[110*u.deg], stream_b=[50*u.deg], gal_angle=[-50*u.deg])\\n \\n match['NGC 5024'] = dict(streams=['sylgr', 'ravi'], direction=[-1, 1], nstep=[300,500], gc_label='NGC\\\\n5024', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=10*u.deg, gcb_off=-20*u.deg, stream_label=['Sylgr', 'Ravi'], stream_ra=[-70*u.deg, 83*u.deg], stream_dec=[2*u.deg, -47*u.deg], eq_angle=[25*u.deg, 65*u.deg], stream_l=[-110*u.deg, -18.5*u.deg], stream_b=[62*u.deg, -47*u.deg], gal_angle=[30*u.deg, -10*u.deg])\\n \\n match['NGC 5139'] = dict(streams=['fimbulthul'], direction=[-1], nstep=[70], gc_label='NGC\\\\n5139', gcra_off=-5*u.deg, gcdec_off=-15*u.deg, gcl_off=0*u.deg, gcb_off=-12*u.deg, stream_label=['Fimbulthul'], stream_ra=[-20*u.deg], stream_dec=[-15*u.deg], eq_angle=[0*u.deg], stream_l=[-20*u.deg], stream_b=[45*u.deg], gal_angle=[0*u.deg])\\n \\n match['NGC 5272'] = dict(streams=['svol'], direction=[1], nstep=[70], gc_label='NGC\\\\n5272', gcra_off=-15*u.deg, gcdec_off=10*u.deg, gcl_off=-23*u.deg, gcb_off=-17*u.deg, stream_label=['$Sv\\\\\\\\\\\\\\\" ol$'], stream_ra=[-2*u.deg], stream_dec=[34*u.deg], eq_angle=[-10*u.deg], stream_l=[55*u.deg], stream_b=[55*u.deg], gal_angle=[-65*u.deg])\\n \\n match['NGC 5824'] = dict(streams=['triangulum', 'turbio'], direction=[1,1], nstep=[700,1], gc_label='NGC\\\\n5824', gcra_off=15*u.deg, gcdec_off=-5*u.deg, gcl_off=15*u.deg, gcb_off=-5*u.deg, stream_label=['Triangulum', 'Turbio'], stream_ra=[152*u.deg, 130*u.deg], stream_dec=[32*u.deg, -51*u.deg], eq_angle=[-48*u.deg, 30*u.deg], stream_l=[120*u.deg, -82*u.deg], stream_b=[-31*u.deg, -57*u.deg], gal_angle=[70*u.deg, 105*u.deg])\\n \\n dt = 0.5*u.Myr\\n wangle = 180*u.deg\\n ra_off = 120*u.deg\\n l_off = 0*u.deg\\n \\n colors = [mpl.cm.plasma(0.95*x/N) for x in range(N)]\\n \\n np.random.seed(27529)\\n if test:\\n Nsample = 1\\n else:\\n Nsample = 100\\n \\n plt.close()\\n fig = plt.figure(figsize=(12,12))\\n \\n ax0 = fig.add_subplot(211, projection='mollweide')\\n ax1 = fig.add_subplot(212, projection='mollweide')\\n ax = [ax0, ax1]\\n \\n for i in range(N):\\n #ind = t['Name']== clusters[i]\\n ind = t['Name']==clusters[i]\\n t_ = t[ind]\\n \\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\\n cgal = c.transform_to(coord.Galactic)\\n #w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\\n \\n color = colors[i]\\n alpha_text = 0.8\\n \\n plt.sca(ax[0])\\n plt.plot((c.ra + ra_off).wrap_at(wangle).rad, c.dec.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\\n plt.text((c.ra + ra_off + match[clusters[i]]['gcra_off']).wrap_at(wangle).rad, (c.dec + match[clusters[i]]['gcdec_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\\n \\n plt.sca(ax[1])\\n plt.plot((cgal.l + l_off).wrap_at(wangle).rad, cgal.b.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\\n plt.text((cgal.l + l_off + match[clusters[i]]['gcl_off']).wrap_at(wangle).rad, (cgal.b + match[clusters[i]]['gcb_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\\n \\n\\n for j in range(len(match[clusters[i]]['direction'])):\\n # sample gc positional uncertainties\\n for k in range(-1, Nsample):\\n if k==-1:\\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\\n \\n lw = 1.5\\n alpha = 1\\n else:\\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'] + np.random.randn()*t_['e_Rsun'], pm_ra_cosdec=t_['pmRA_'] + np.random.randn()*t_['e_pmRA_'], pm_dec=t_['pmDE'] + np.random.randn()*t_['e_pmDE'], radial_velocity=t_['RV'] + np.random.randn()*t_['e_RV'], frame='icrs')\\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\\n \\n lw = 1\\n alpha = 0.1\\n \\n orbit = ham.integrate_orbit(w0, dt=dt*match[clusters[i]]['direction'][j], n_steps=match[clusters[i]]['nstep'][j])\\n orbit_eq = orbit.to_coord_frame(coord.ICRS, galactocentric_frame=gc_frame)\\n orbit_gal = orbit.to_coord_frame(coord.Galactic, galactocentric_frame=gc_frame)\\n \\n \\n plt.sca(ax[0])\\n dra = (orbit_eq.ra+ra_off).wrap_at(wangle)[1:] - (orbit_eq.ra+ra_off).wrap_at(wangle)[:-1]\\n if np.any(np.abs(dra)>180*u.deg):\\n pos_break = dra>180*u.deg\\n ind_break = np.argmax(pos_break)\\n ipad = 1\\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_eq.dec.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_eq.dec.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\\n else:\\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad, orbit_eq.dec.rad, '-', color=color, lw=lw, label='', alpha=alpha)\\n \\n plt.sca(ax[1])\\n dl = orbit_gal.l.wrap_at(wangle)[1:] - orbit_gal.l.wrap_at(wangle)[:-1]\\n if np.any(np.abs(dl)>180*u.deg):\\n pos_break = dl>180*u.deg\\n ind_break = np.argmax(pos_break)\\n ipad = 1\\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_gal.b.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_gal.b.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\\n else:\\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad, orbit_gal.b.rad, '-', color=color, lw=lw, label='', alpha=alpha)\\n \\n # add streams\\n pkl = pickle.load(open('../data/streams/data_{:s}.pkl'.format(match[clusters[i]]['streams'][j]), 'rb'))\\n cs = coord.SkyCoord(ra=pkl['dec'][0], dec=pkl['dec'][1], frame='icrs')\\n cs_gal = cs.transform_to(coord.Galactic)\\n \\n plt.sca(ax[0])\\n plt.plot((cs.ra+ra_off).wrap_at(wangle).rad, cs.dec.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\\n plt.text(coord.Longitude(match[clusters[i]]['stream_ra'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_dec'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['eq_angle'][j].value, ha='center', va='center')\\n \\n plt.sca(ax[1])\\n plt.plot((cs_gal.l+l_off).wrap_at(wangle).rad, cs_gal.b.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\\n plt.text(coord.Longitude(match[clusters[i]]['stream_l'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_b'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['gal_angle'][j].value, ha='center', va='center')\\n \\n \\n plt.sca(ax[0])\\n plt.grid(ls=':')\\n plt.xlabel('R.A. [deg]')\\n plt.ylabel('Dec [deg]')\\n\\n plt.gca().xaxis.set_ticklabels([])\\n \\n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\\n xloc = np.delete(xloc, [3])\\n yloc = coord.Latitude(5*u.deg)\\n Nx = len(xloc)\\n \\n for i in range(Nx):\\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\\\degree$'.format((xloc[i]-ra_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\\n \\n \\n plt.sca(ax[1])\\n plt.grid(ls=':')\\n plt.xlabel('Galactic longitude [deg]')\\n plt.ylabel('Galactic latitude [deg]')\\n \\n plt.gca().xaxis.set_ticklabels([])\\n \\n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\\n xloc = np.delete(xloc, [2,3])\\n yloc = coord.Latitude(5*u.deg)\\n Nx = len(xloc)\\n \\n for i in range(Nx):\\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\\\degree$'.format((xloc[i]+l_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\\n \\n \\n \\n plt.tight_layout(h_pad=2)\\n plt.savefig('../paper/sky_orbits.pdf')\",\n \"def branchNBound2(nationtxt, bound, scheme):\\n\\n\\n nation = nationLoader(nationtxt)\\n transmitterCosts = scheme\\n\\n neighborCount = {}\\n for province in nation:\\n neighborCount.update({province:len(nation.get(province)[0])})\\n\\n\\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\\n\\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\\n\\n for key in neighborCountSorted:\\n provinces.append(key)\\n #~ print provinces\\n\\n upperbound = bound\\n #~ print bound\\n\\n\\n\\n solution = []\\n\\n\\n counter = 0\\n\\n\\n\\n\\n while index >= 0:\\n\\n counter += 1\\n if counter % 100000000 == 0:\\n print counter\\n print \\\"Now at:\\\", nation\\n\\n\\n if index == -1:\\n break\\n\\n # Assign transmitter\\n if nation[provinces[index]][1] == numTransmitters:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n else:\\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\\n\\n # Check if costs are above upper bound\\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n # Check if a neighbor has the same transmitter\\n conflict = False\\n for neighbor in nation[provinces[index]][0]:\\n if nation[neighbor][1] == nation[provinces[index]][1]:\\n conflict = True\\n break\\n\\n if conflict:\\n continue\\n\\n # Check if a solution is found\\n if index == len(provinces) - 1:\\n #~ print \\\"\\\\nSOLUTION:\\\"\\n if costs < upperbound:\\n solution = []\\n solution.append(json_deep_copy(nation))\\n upperbound = costs\\n #~ print \\\"Score:\\\", upperbound\\n #~ print nation\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n index += 1\\n\\n\\n\\n usedTrans = []\\n fivePlus = 0\\n fivePlusNoDuplicate = 0\\n\\n for nation in solution:\\n\\n one = 0\\n two = 0\\n three = 0\\n four = 0\\n five = 0\\n six = 0\\n seven = 0\\n\\n for province in nation:\\n\\n if nation[province][1] == 1:\\n one += 1\\n if nation[province][1] == 2:\\n two += 1\\n if nation[province][1] == 3:\\n three += 1\\n if nation[province][1] == 4:\\n four += 1\\n if nation[province][1] == 5:\\n five += 1\\n if nation[province][1] == 6:\\n six += 1\\n if nation[province][1] == 7:\\n seven += 1\\n\\n\\n if five > 0 or six > 0 or seven > 0:\\n fivePlus += 1\\n if transmitterCosts[3] != transmitterCosts[4]:\\n fivePlusNoDuplicate += 1\\n\\n usedTrans.append([one, two, three, four, five, six, seven])\\n\\n return counter\",\n \"def heads_legs(heads, legs):\\n for i in range(0, heads + 1):\\n cows = heads - i\\n if 4 * cows + 2 * i == legs:\\n chickens = i\\n return chickens, cows\\n return \\\"No solutions.\\\"\",\n \"def earliest_arrival(jump_distance, stones):\\n #jump_distance of 3 means they skip 2 stones and land on 3rd\\n stone = ''\\n #based on jump_distance, what are all the stone nums within that distance\\n #when jump_distance is 5, can jujp to stones[4]\\n \\n stone = min(stones[:(jump_distance - 1)]) #stone = 2\\n\\n t = max(0, stone) #t = 2\\n print(f't starts at = {t}')\\n i = stones.index(stone) # i = 1\\n print(f'i starts at = {i}') \\n #as long as \\n while i + jump_distance <= len(stones) - 1: # 3 + 5 <= 7\\n print(f'i + jump_distance = {i + jump_distance}')\\n\\n stone = min(stones[(i + 1):(i + jump_distance)]) #stone = 3\\n print(f'stone: {stone}')\\n if t < stone: \\n t = stone #reassign to 3\\n \\n i = stones.index(stone) # i = 2\\n print(f'i = {i}') \\n stone = min(stones[(i + 1):(i + jump_distance)]) #stone \\n t = max(t, stone)\\n print(f'end of while loop: t = {t}') \\n \\n return t\\n #what's the lowest num within that jump_distance \\n #go to that stone, then look at next stones in new jump_distance\\n #t becomes whatever stone we jumped to\\n #if the next stone we jump to is a higher value, reassign t\\n #get length of list of stones so we don't go past length\\n #var assigned to len(list) and compare to index we're at \\n #if index we're jumping to is higher than len of list, then we're done\\n #control for indexerror with while loop?\\n # \",\n \"def spotlessroomba_second_heuristic(state : SpotlessRoombaState) -> float:\\n # TODO a nontrivial consistent heuristic\\n \\n if not state.dirty_locations:\\n return 0\\n \\n best_start = 0 # best dirty tile to start from\\n best_cost = INF # cost of the path from the above start tile\\n\\n for i in range(len(state.dirty_locations)):\\n estimate_cost = 0\\n lowest_cost = INF\\n closest_dirty = 0\\n dirty_locations = list(state.dirty_locations)\\n current_pos = dirty_locations.pop(i)\\n\\n # find the shortest cost solution path from this starting tile\\n while dirty_locations:\\n for j in range(len(dirty_locations)):\\n manhattan = abs(current_pos.row - dirty_locations[j].row) + abs(current_pos.col - dirty_locations[j].col)\\n if manhattan < lowest_cost:\\n lowest_cost = manhattan\\n closest_dirty = j\\n estimate_cost += lowest_cost\\n current_pos = dirty_locations.pop(closest_dirty)\\n lowest_cost = INF\\n # if estimated path cost is cheaper than best path cost so far, replace best_cost and best_start\\n if estimate_cost < best_cost:\\n best_cost = estimate_cost\\n best_start = i\\n # if estimated path cost and best path cost so far are equal, tiebreak with proximity to start tile\\n if estimate_cost == best_cost:\\n current_pos = state.position\\n dist_to_prev_best = abs(current_pos.row - state.dirty_locations[best_start].row) + abs(current_pos.col - state.dirty_locations[best_start].col)\\n dist_to_i = abs(current_pos.row - state.dirty_locations[i].row) + abs(current_pos.col - state.dirty_locations[i].col)\\n if dist_to_i < dist_to_prev_best:\\n best_start = i\\n \\n\\n current_pos = state.position\\n # Calculate distance to the best start tile\\n dist_to_start = abs(current_pos.row - state.dirty_locations[best_start].row) + abs(current_pos.col - state.dirty_locations[best_start].col)\\n # Returned heuristic is the sum of distance to the start tile and estimated cost from said tile\\n return dist_to_start + best_cost\",\n \"def fn(i, s0, s1, c0, c1):\\n if s0 > n or s1 > n: return 0 # impossible \\n if i == len(balls): return int(c0 == c1)\\n ans = 0 \\n for x in range(balls[i]+1): \\n ans += fn(i+1, s0+x, s1+balls[i]-x, c0+(x > 0), c1+(x < balls[i])) * comb(balls[i], x)\\n return ans\",\n \"def solution(A):\\n \\n cars = 0\\n ones = 0\\n\\n for i in range(len(A), 0, -1):\\n\\n if A[i-1] == 1:\\n ones += 1\\n else:\\n cars += ones\\n\\n return (-1 if cars > 1000000000 else cars)\",\n \"def find_all_ORFs_both_strands(dna):\\n \\n # YOUR IMPLEMENTATION HERE\",\n \"def gameOfStones(n):\\n winning_start = set([2, 3, 4, 5]) # 7 we don't know who would win yet\\n losing_start = set([0, 1])\\n\\n def n_remain(n_):\\n n_next = set([n_ - x for x in [2, 3, 5] if n_ - x >= 0])\\n return n_next\\n\\n i = 0\\n while i < n + 1:\\n x = n_remain(i)\\n # let's build lookup table to see what each value of up to n yields as\\n # far as winner under optimal play\\n if i in winning_start:\\n # print('Player 1 wins')\\n pass\\n elif i in losing_start:\\n # print('Player 2 wins')\\n pass\\n elif len(losing_start.intersection(x)) > 0:\\n # if player 1 has any option that is a losing start, he win\\n print(i, 'Adding to winning start', x)\\n winning_start.add(i)\\n elif len(winning_start.intersection(x)) == len(x):\\n # if player 1 gives player 2 only winning options, p1 loses\\n print(i, 'Adding to losing start', x)\\n losing_start.add(i)\\n else:\\n print('this should never happen')\\n i += 1\\n\\n if n in winning_start:\\n print('First')\\n return 'First'\\n else:\\n print('Second')\\n return 'Second'\",\n \"def Solve(bases):\\r\\n n = 1\\r\\n while 1:\\r\\n n += 1\\r\\n done = True\\r\\n for b in bases:\\r\\n if not Happy(n, b):\\r\\n done = False\\r\\n break\\r\\n if done:\\r\\n return n\",\n \"def myHeuristic3(state, problem=None):\\n #canto =[(1,1), (1,2), (2,1), (2,2), (36,36), (35,36), (35,35), (36,35), (1,36),(1,35),(2,36),(2,35),(36,1),(36,2),(35,1),(35,2)]\\n canto = []\\n for l in range(2):\\n for c in range(2):\\n canto.append((l,c))\\n heru = abs(state[0] - 1) + abs(state[1] - 1)\\n #heru=10\\n if state in canto:\\n #print(\\\"sim\\\")\\n heru = heru * 0.5\\n return heru\",\n \"def test_teleport_minimal_basis_gates(self):\\n shots = 2000\\n circuits = ref_algorithms.teleport_circuit()\\n targets = ref_algorithms.teleport_counts(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX')\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)\",\n \"def branchNBound(nationtxt, bound, scheme):\\n provinces = []\\n index = 0\\n costs = 0\\n numTransmitters = 7\\n\\n transmitterCosts = scheme\\n nation = nationLoader(nationtxt)\\n\\n\\n neighborCount = {}\\n for province in nation:\\n neighborCount.update({province:len(nation.get(province)[0])})\\n\\n\\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\\n\\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\\n\\n for key in neighborCountSorted:\\n provinces.append(key)\\n #~ print provinces\\n\\n upperbound = bound\\n #~ print bound\\n #~ print bound\\n\\n\\n\\n solution = []\\n\\n\\n counter = 0\\n\\n\\n\\n\\n\\n while index >= 0:\\n\\n\\n counter += 1\\n if counter % 100000000 == 0:\\n print counter\\n print \\\"Now at:\\\", nation\\n\\n\\n if index == -1:\\n break\\n\\n # Assign transmitter\\n if nation[provinces[index]][1] == numTransmitters:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n else:\\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\\n\\n # Check if costs are above upper bound\\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n # Check if a neighbor has the same transmitter\\n conflict = False\\n for neighbor in nation[provinces[index]][0]:\\n if nation[neighbor][1] == nation[provinces[index]][1]:\\n conflict = True\\n break\\n\\n if conflict:\\n continue\\n\\n # Check if a solution is found\\n if index == len(provinces) - 1:\\n #~ print \\\"\\\\nSOLUTION:\\\"\\n if costs < upperbound:\\n solution = []\\n solution.append(json_deep_copy(nation))\\n upperbound = costs\\n #~ print \\\"Score:\\\", upperbound\\n #~ print nation\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n index += 1\\n\\n\\n usedTrans = []\\n fivePlus = 0\\n fivePlusNoDuplicate = 0\\n\\n for nation in solution:\\n\\n one = 0\\n two = 0\\n three = 0\\n four = 0\\n five = 0\\n six = 0\\n seven = 0\\n\\n for province in nation:\\n\\n if nation[province][1] == 1:\\n one += 1\\n if nation[province][1] == 2:\\n two += 1\\n if nation[province][1] == 3:\\n three += 1\\n if nation[province][1] == 4:\\n four += 1\\n if nation[province][1] == 5:\\n five += 1\\n if nation[province][1] == 6:\\n six += 1\\n if nation[province][1] == 7:\\n seven += 1\\n\\n\\n if five > 0 or six > 0 or seven > 0:\\n fivePlus += 1\\n if transmitterCosts[3] != transmitterCosts[4]:\\n fivePlusNoDuplicate += 1\\n\\n usedTrans.append([one, two, three, four, five, six, seven])\\n\\n return fivePlus, fivePlusNoDuplicate, usedTrans, upperbound, len(solution), counter\\n #~ f.write(\\\"\\\\n Used Transmitters: \\\"+ str(one)+\\\" \\\"+ str(two)+\\\" \\\"+ str(three)+\\\" \\\"+ str(four)+\\\" \\\"+ str(five)+\\\" \\\"+ str(six)+\\\" \\\"+ str(seven)+\\\"\\\\n Cost: \\\"+str(upperbound)+\\\"\\\\n Number of solutions: \\\"+str(len(solution))+\\\"\\\\n Iterations: \\\"+str(counter)+\\\"\\\\n\\\"+\\\"\\\\n\\\"+\\\"\\\\n\\\"+\\\"\\\\n\\\")\\n\\n #~ print \\\"transmitter frequecies:\\\", one, two, three, four, five, six, seven\\n #~ print \\\"Solutions:\\\", solution\\n #~ print \\\"Cost:\\\", upperbound\\n #~ print \\\"Number of solutions:\\\", len(solution)\\n #~ print \\\"Iterations:\\\", counter\",\n \"def solve(k=[]):\\n if len(k) < 2:\\n return 1\\n min_jumps = len(k)\\n for i in reversed(range(k[0])):\\n if i > len(k):\\n return 1\\n if k[i] != 0:\\n sub_jumps = solve(k[i + 1 :])\\n min_jumps = min(min_jumps, sub_jumps)\\n return min_jumps\",\n \"def main():\\n LIMIT = 600\\n GOAL = 1000\\n for i in range(1, LIMIT + 1):\\n for j in range(1, LIMIT + 1):\\n for k in range(1, LIMIT + 1):\\n if i + j + k == GOAL:\\n if i**2 == j**2 + k**2:\\n print \\\"GOAL:\\\", (i, j, k)\",\n \"def occam_razor() -> None:\\r\\n print(\\\"WARNING! Mode three activated. Time to complete may be several minutes\\\")\\r\\n temp = [] # x-y-conflicts\\r\\n global example\\r\\n backup = example.copy() # Backup so it can backtrack through solutions\\r\\n for x in range(shape):\\r\\n for y in range(shape):\\r\\n conflict_counter = 0\\r\\n for z in range(shape):\\r\\n if conflict_space[x, y] != 0:\\r\\n if conflict_space[x, y] == conflict_space[x, z] and z != y:\\r\\n conflict_counter += 1\\r\\n if conflict_space[x, y] == conflict_space[z, y] and z != x:\\r\\n conflict_counter += 1\\r\\n if conflict_counter > 0 and no_neighbour(x, y):\\r\\n temp.append([x, y, conflict_counter])\\r\\n threshold = [0, 0, 0]\\r\\n \\\"\\\"\\\"Takes an educated guess on the node in most conflict in case it's one move away from being solved\\\"\\\"\\\"\\r\\n for x in range(len(temp)):\\r\\n if temp[x][2] > threshold[2]:\\r\\n threshold = temp[x]\\r\\n if threshold[2] > 0:\\r\\n example[threshold[0], threshold[1]] = 0\\r\\n shade_neighbours(threshold[0], threshold[1])\\r\\n if not victory_checker():\\r\\n \\\"\\\"\\\"code now begins guessing\\\"\\\"\\\"\\r\\n for x in range(len(temp)):\\r\\n example = backup.copy()\\r\\n if no_neighbour(temp[x][0], temp[x][1]):\\r\\n example[temp[x][0], temp[x][1]] = 0\\r\\n else:\\r\\n continue\\r\\n progress_handler(False, True)\\r\\n while progress_handler(True, False):\\r\\n print_debug(\\\"itteration\\\")\\r\\n progress_handler(False, False)\\r\\n mark_check()\\r\\n if victory_checker():\\r\\n completion(True)\\r\\n if not progress_handler(True, False):\\r\\n special_corner()\\r\\n if not progress_handler(True, False):\\r\\n separation_crawler(True)\\r\\n if not progress_handler(True, False):\\r\\n occam_razor() # Recursive\\r\\n if not progress_handler(True, False):\\r\\n if victory_checker():\\r\\n completion(True)\\r\\n else:\\r\\n print(\\\"Searching...\\\")\\r\\n continue\\r\\n conflict_check()\",\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n\\n # print(num_wizards)\\n # print(num_constraints)\\n # print(wizards)\\n # print(constraints)\\n # node_set = set(wizards)\\n \\n\\n\\n def cost(sol,num_constraints,constraints):\\n constraints_satisfied = 0\\n constraints_failed = []\\n output_ordering_map = {k: v for v, k in enumerate(sol)}\\n for c in constraints:\\n\\n m = output_ordering_map # Creating an alias for easy reference\\n\\n wiz_a = m[c[0]]\\n wiz_b = m[c[1]]\\n wiz_mid = m[c[2]]\\n\\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\\n constraints_failed.append(c)\\n else:\\n constraints_satisfied += 1\\n return num_constraints - constraints_satisfied\\n\\n def neighbors(sol):\\n wiz1 = random.randint(0,num_wizards-1)\\n wiz2 = random.randint(0,num_wizards-1)\\n\\n new_sol = copy.copy(sol)\\n temp = new_sol[wiz1]\\n new_sol[wiz1] = new_sol[wiz2]\\n new_sol[wiz2] = temp\\n \\n return new_sol\\n\\n def acceptance_probability(old_cost,new_cost,T):\\n exponent = (old_cost - new_cost) / T\\n \\n try:\\n ans = math.exp(exponent)\\n except OverflowError:\\n ans = float('inf')\\n return ans\\n\\n\\n def anneal(solution, num_constraints, constraints):\\n old_cost = 0\\n new_cost = 0\\n old_cost = cost(solution,num_constraints,constraints)\\n T = 1.0\\n T_min = 0.000001\\n alpha = 0.98\\n while T > T_min:\\n i = 1\\n while i <= 1000:\\n new_solution = neighbors(solution)\\n new_cost = cost(new_solution,num_constraints,constraints)\\n if new_cost == 0:\\n return new_solution,new_cost\\n ap = acceptance_probability(old_cost, new_cost, T)\\n if ap > random.random():\\n solution = new_solution\\n old_cost = new_cost\\n i += 1\\n T = T*alpha\\n return solution, old_cost\\n\\n s = copy.copy(wizards)\\n random.shuffle(s)\\n ret = anneal(s,num_constraints,constraints)\\n \\n for i in range(10):\\n if ret[1] == 0:\\n break\\n random.shuffle(s)\\n new_ret = anneal(s,num_constraints,constraints)\\n print(i)\\n if new_ret[1] < ret[1]:\\n ret = new_ret\\n print(\\\"constraints failed: {0}\\\".format(ret[1]))\\n return ret[0]\",\n \"def solution(n: int = 28123) -> int:\\n\\n nums = range(1, n+1)\\n abundant = list(filter(is_abundant, nums))\\n abundant_sums = set(all_sums(abundant, n))\\n fit = set(nums) - abundant_sums\\n return fit\",\n \"def find_non_trivial_orbit(generators: [Permutation]) -> int:\\n if not generators:\\n return None\\n n = generators[0].n\\n for P in generators:\\n for element in range(n):\\n if P[element] != element:\\n return element\",\n \"def brute_force(city_list):\\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,6)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 6 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 6 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\"-\\\")\\n \\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,7)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 7 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 7 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\"-\\\")\\n \\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,8)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 8 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 8 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\"-\\\")\\n \\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,9)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 9 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 9 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\"-\\\")\\n \\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,10)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 10 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 10 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\" \\\")\",\n \"def __checkvictory__(self,playerchar):\\n\\t\\tvictory = False\\n\\t\\tboardx = deepcopy(self.board)\\n\\t\\trow = 5\\n\\t\\tcolumn = 6\\n\\t\\tstarburst_bag = []\\n\\t\\tcats_game = True\\n\\t\\tfor a in range(row+1):\\n\\t\\t\\tfor b in range(column+1):\\n\\t\\t\\t\\tstarburst = []\\n\\t\\t\\t\\tstarburst.append((a,b))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif self.__checkplace__(a,b) is True:\\n\\t\\t\\t\\t\\tcats_game = False\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telif self.__checkplace__(a,b) == playerchar:\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst.append(1)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\twhile True:\\n\\t\\t\\t\\t\\t\\tif a-starburst[1] < 0:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif self.__checkplace__(a-starburst[1],b) == playerchar:\\n\\t\\t\\t\\t\\t\\t\\tstarburst[1] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst.append(1)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\twhile True:\\n\\t\\t\\t\\t\\t\\tif a-starburst[2] < 0:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif b+starburst[2] > 6:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif self.__checkplace__(a-starburst[2],b+starburst[2])\\\\\\n\\t\\t\\t\\t\\t\\t == playerchar:\\n\\t\\t\\t\\t\\t\\t\\tstarburst[2] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst.append(1)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\twhile True:\\n\\t\\t\\t\\t\\t\\tif b+starburst[3] > 6:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif self.__checkplace__(a,b+starburst[3]) == playerchar:\\n\\t\\t\\t\\t\\t\\t\\tstarburst[3] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst.append(1)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\twhile True:\\n\\t\\t\\t\\t\\t\\tif a+starburst[4] > 5:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif b+starburst[4] > 6:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif self.__checkplace__(a+starburst[4],b+starburst[4])\\\\\\n\\t\\t\\t\\t\\t\\t== playerchar:\\n\\t\\t\\t\\t\\t\\t\\tstarburst[4] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst_bag.append(starburst)\\n\\t\\t\\n\\t\\tfor starburst in starburst_bag:\\n\\t\\t\\t\\n\\t\\t\\ta = starburst[0][0]\\n\\t\\t\\tb = starburst[0][1]\\n\\t\\t\\t\\n\\t\\t\\tif starburst[1] > 3:\\n\\t\\t\\t\\tvictory = True\\n\\t\\t\\t\\tfor i in range(starburst[1]):\\n\\t\\t\\t\\t\\tboardx[a-i][b] = boardx[a-i][b].\\\\\\n\\t\\t\\t\\t\\treplace(playerchar,playerchar.upper())\\n\\t\\t\\tif starburst[2] > 3:\\n\\t\\t\\t\\tvictory = True\\n\\t\\t\\t\\tfor i in range(starburst[2]):\\n\\t\\t\\t\\t\\tboardx[a-i][b+i] = boardx[a-i][b+i].\\\\\\n\\t\\t\\t\\t\\treplace(playerchar,playerchar.upper())\\n\\t\\t\\tif starburst[3] > 3:\\n\\t\\t\\t\\tvictory = True\\n\\t\\t\\t\\tfor i in range(starburst[3]):\\n\\t\\t\\t\\t\\tboardx[a][b+i] = boardx[a][b+i].\\\\\\n\\t\\t\\t\\t\\treplace(playerchar,playerchar.upper())\\n\\t\\t\\tif starburst[4] > 3:\\n\\t\\t\\t\\tvictory = True\\n\\t\\t\\t\\tfor i in range(starburst[4]):\\n\\t\\t\\t\\t\\tboardx[a+i][b+i] = boardx[a+i][b+i].\\\\\\n\\t\\t\\t\\t\\treplace(playerchar,playerchar.upper())\\n\\t\\t\\t\\n\\t\\tif cats_game:\\n\\t\\t\\treturn None\\n\\t\\tif victory:\\n\\t\\t\\treturn boardx\\n\\t\\telse:\\n\\t\\t\\treturn False\",\n \"def find_santa(curr_pos=src, prev_pos='YOU', transfers=0):\\n if curr_pos == dst: # base case: we found it!\\n return transfers\\n\\n # let's try moving inward (unless that would be retracing our steps)\\n parent = orbits[curr_pos]['parent']\\n if parent is not None and parent != prev_pos:\\n possible_route = find_santa(curr_pos=parent, prev_pos=curr_pos, transfers=transfers+1)\\n if possible_route is not False:\\n return possible_route\\n\\n # if we're still here, inward didn't work. let's move outward...\\n children = [c for c in orbits[curr_pos]['children'] if c != prev_pos] # don't retrace steps\\n for child in children:\\n possible_route = find_santa(curr_pos=child, prev_pos=curr_pos, transfers=transfers+1)\\n if possible_route is not False:\\n return possible_route\\n\\n # at this point there are no possible routes. return false\\n return False\",\n \"def find():\\n b = 0\\n q = 0\\n while b == q:\\n seq = [randint(-10, 10) for _ in range(randint(15, 30))]\\n b, b_at = brute_force(seq)\\n q = solution(seq)\\n print(seq, b, q, b_at)\",\n \"def lowest_cost_search(start, successors, is_goal, action_cost):\\r\\n # your code here\\r\\n explored = set()\\r\\n frontier = [ [start] ]\\r\\n while frontier:\\r\\n path = frontier.pop(0)\\r\\n state1 = final_state(path)\\r\\n if is_goal(state1):\\r\\n return path\\r\\n explored.add(state1)\\r\\n pcost = path_cost(path)\\r\\n for (state, action) in successors(state1).items():\\r\\n if state not in explored:\\r\\n total_cost = pcost + action_cost(action)\\r\\n path2 = path [(action, total_cost), state]\\r\\n add_to_frontier(frontier, path2)\\r\\n return Fail\",\n \"def McNuggets(n):\\n # Your Code Here\\n for c in xrange( n/20+2):\\n for b in xrange( (n-20*c)/9+2):\\n for a in xrange ((n-20*c-9*b)/6 +2):\\n if (6*a + 9*b + 20*c) == n :\\n return True\\n return False\",\n \"def _is_this_healthy_rDNA(self):\\n if self.length < 3000:\\n return 0\\n mapping_state = []\\n for item in self.sam_summary:\\n if item[1] != '0':\\n mapping_state.append(1)\\n else:\\n mapping_state.append(0)\\n threshold = 0.8\\n if sum(mapping_state)/len(mapping_state) > threshold:\\n return 1\\n else:\\n for i in range(1, len(mapping_state) - 50):\\n if sum(mapping_state[i:])/len(mapping_state[i:]) > threshold or \\\\\\n sum(mapping_state[:-i])/len(mapping_state[:-i]) > threshold:\\n healthy = 2\\n return 0\",\n \"def brute_force(seats):\\n for seat in seats:\\n if seat + 1 not in seats and seat + 2 in seats:\\n return seat + 1\\n\\n return None\",\n \"def goal_test(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n shoot_loc_arr = []\\n for allowed_state in self.allowed:\\n for goal_state in self.goals:\\n if allowed_state[0] == goal_state[0] and allowed_state[1] < goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 0)) # Head North\\n if allowed_state[0] > goal_state[0] and allowed_state[1] == goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 1)) # Head West\\n if allowed_state[0] == goal_state[0] and allowed_state[1] > goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 2)) # Head South\\n if allowed_state[0] < goal_state[0] and allowed_state[1] == goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 3)) # Head East\\n if state in shoot_loc_arr:\\n return True\\n else:\\n return False\",\n \"def N_states_for_learner(self):\\n idx_max = []\\n limits = 50, 2*_math.pi, 50, 50, 50, 50, 50, 50, 50\\n for idx, limit in enumerate(limits):\\n test = [0 for i in xrange(len(limits))]\\n check = _arange(-limit,limit,limit/1000.)\\n maxi = 0\\n for v in check:\\n test[idx]=v\\n ret = self._state_index(*test)\\n maxi = max((maxi, ret[idx]))\\n idx_max.append(maxi)\\n\\n return tuple([idx+1 for idx in idx_max])\",\n \"def getSuccessors(self, state):\\n\\n successors = []\\n top, right = self.walls.height - 2, self.walls.width - 2\\n for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:\\n # Add a successor state to the successor list if the action is legal\\n # Here's a code snippet for figuring out whether a new position hits a wall:\\n x, y = state[0]\\n dx, dy = Actions.directionToVector(action)\\n nextx, nexty = int(x + dx), int(y + dy)\\n hitsWall = self.walls[nextx][nexty]\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\\"\\\"\\\"\\n La función sucesores funciona de la siguiente manera:\\n * Si la acción no hace que choque con una pared, entonces...\\n - Defino nextState como las coordenadas de lo que me da la acción\\n - Creo una copia de la grid de true/false que tiene el estado, para así no modificar la original\\n - A esta copia le actualizo la información, si el sucesor es una de las esquinas. Tengo que realizar\\n esto manualmente dada la definición de mi grid de booleanos.\\n - Creo una nueva variable que es una tupla en la que inserto las nuevas coordenadas y la grid actualizada\\n - La añado a la lista de sucesores\\n \\\"\\\"\\\"\\n if not hitsWall:\\n nextState = (nextx, nexty) # Defino la tupla que será la posición del sucesor\\n nextFood = state[1].copy() # Hago una copia para así poder modificarla tranquilamente\\n if nextState == (1, 1): # Manualmente miro si es alguna de las esquinas\\n nextFood[1][0] = False # Si lo es, actualizo de true a false el elemento correspondiente\\n if nextState == (1, top):\\n nextFood[0][0] = False\\n if nextState == (right, 1):\\n nextFood[1][1] = False\\n if nextState == (right, top):\\n nextFood[0][1] = False\\n nextStateFood = (nextState, nextFood) # Lo añado como tupla\\n cost = 1 # Por orden del enunciado, el coste es siempre 1\\n successors.append((nextStateFood, action, cost)) # Lo añado a la lista de sucesores\\n self._expanded += 1\\n return successors\",\n \"def greedy(self, state, timestep, epsilon=0):\\n\\n counts = np.bincount(self.call_locs, minlength=self.num_nodes)\\n # print(self.lengths)\\n # print(counts)\\n score = self.lengths @ counts\\n action = []\\n for _ in range(self.num_ambulance):\\n node = np.argmin(score)\\n action.append(node)\\n score[node] = 99999999\\n return action\",\n \"def uniform_cost_search(problem):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n fringe = util.PriorityQueue()\\r\\n path = set()\\r\\n final = []\\r\\n acts = dict()\\r\\n state = problem.get_start_state()\\r\\n fringe.push(state, 0)\\r\\n\\r\\n while (True):\\r\\n state = fringe.pop()\\r\\n path.add(state)\\r\\n states = problem.get_successors(state)\\r\\n acts[state] = states[:]\\r\\n if problem.is_goal_state(state):\\r\\n break\\r\\n\\r\\n #states = problem.get_successors(state)\\r\\n # push into fringe\\r\\n for stat in states:\\r\\n if stat[0] not in path:\\r\\n fringe.push(stat[0], stat[1].piece.get_num_tiles()) #problem.get_cost_of_actions([stat[1]])\\r\\n\\r\\n while (True):\\r\\n if state == problem.get_start_state():\\r\\n break\\r\\n for key, val in acts.items():\\r\\n for va in val:\\r\\n if va[0] == state:\\r\\n final.append(va[1])\\r\\n state = key\\r\\n break\\r\\n else:\\r\\n continue\\r\\n break\\r\\n\\r\\n final.reverse()\\r\\n\\r\\n return final\",\n \"def calculate_image_possibilities():\\n\\n # Reordering the color ramps in the palette yields 3! combinations\\n palette_reorder_possibilities = 6\\n\\n return len(palettes) * palette_reorder_possibilities * len(grips) * len(pommels) * len(crossguards) * len(blades)\",\n \"def manhattan_heuristic(state):\\n man_h = 0\\n size = len(state)\\n for i in range (size):\\n for j in range (size):\\n if state[i][j] == 0:\\n continue\\n else:\\n man_h = man_h + abs(i - int(state[i][j]/3)) + abs(j - (state[i][j])%3)\\n return man_h\",\n \"def nextMoveDecision(self):\\n b = random.randint(1, 9) \\n while (self.Occupied(b)):\\n b = random.randint(1, 9) \\n return b\",\n \"def efficient_sol(rt=\\\"O(n)\\\"):\\n def bribe_count(L): # L = line\\n bribes = 0\\n # from back to front\\n for i in range(len(L) - 1, -1, -1):\\n\\n expected_index = i + 1\\n # Case 1: Expected Person already in the right spot.\\n if L[i] == expected_index:\\n continue\\n\\n # Case 2: Expected Person is 1 step away. Swap.\\n elif L[i - 1] == expected_index:\\n L[i], L[i - 1] = L[i - 1], L[i]\\n bribes += 1\\n\\n # Case 3: Expected person is 2 steps away. Put into proper place and other 2 up.\\n elif L[i - 2] == expected_index:\\n L[i - 2], L[i - 1], L[i] = L[i - 1], L[i], L[i - 2]\\n bribes += 2\\n else:\\n return \\\"Too chaotic\\\" # Expected person is more than 2 steps away.\\n return bribes\\n\\n test_count = int(input())\\n for _ in range(test_count):\\n input()\\n line = list(map(int, input().split()))\\n print(bribe_count(line))\",\n \"def findHeuristic(self, _, __):\\n popSize = 100\\n retain = 0.25\\n random_select = 0.1\\n mutate = 0.1\\n\\n popList = self.populationList(popSize)\\n\\n solved = False\\n count = 0\\n while not solved:\\n # evolves current\\n popList = (self.evolve(popList, retain, random_select, mutate))\\n# print(popList) # for troubleshooting\\n for i in popList:\\n if (self.fitness(i) == 0):\\n print(\\\"solution: \\\", i)\\n solved = True\\n break\\n # if plateus at a local minima, then end after 50 generations\\n if count >= 50:\\n if (self.fitness(i) <= 10):\\n print(\\\"solution: \\\", i)\\n solved = True\\n break\\n if solved is True:\\n break\\n print(\\\"-----------------\\\")\\n\\n # will modify mutation, random_select and retain values to help leave a\\n # local minima. More randomness the longer it takes up to specific points\\n if count % 3 == 0:\\n if mutate < 0.2:\\n mutate += 0.01\\n if random_select < 0.3:\\n random_select += 0.01\\n count += 1\\n\\n return exit(0)\",\n \"def solve(given: np.array) -> np.array:\\n possible = np.full((9, 9, 9), True)\\n mask = given > 0\\n possible[mask, :] = False\\n possible[mask, given[mask] - 1] = True\\n\\n # number of possibilities at each site, masking those already propagated\\n # to avoid repetitive work. All masked == problem solved\\n count = ma.array(possible.sum(axis=2), fill_value=1)\\n\\n # allocate upfront to as out parameter to np.equal\\n # (ma.array because count is ma.array)\\n where = ma.array(np.empty((9, 9), dtype=bool), fill_value=False)\\n\\n stack = [(possible, count)]\\n while stack:\\n node, count = stack.pop()\\n unsolved = propagate(node, count, where)\\n if unsolved == -1:\\n continue\\n if unsolved == 0:\\n break\\n # try all possibilities from cell with fewest > 1\\n i, j = np.unravel_index(count.argmin(), count.shape)\\n for k in np.flatnonzero(node[i, j, :]):\\n node_copy, count_copy = node.copy(), count.copy()\\n node_copy[i, j, :] = False\\n node_copy[i, j, k] = True\\n count_copy[i, j] = 1\\n stack.append((node_copy, count_copy))\\n\\n i, j, k = node.nonzero()\\n count[i, j] = k + 1\\n return np.array(count)\",\n \"def McNuggets(n):\\n \\n '''if n == 0:\\n return True\\n for i in (6, 9, 20):\\n if n >= i and McNuggets(n - i):\\n return True\\n return False\\n '''\\n \\n for a in range(0,n):\\n for b in range(0,n):\\n for c in range(0,n):\\n if 6*a+9*b+20*c == n:\\n return True\\n return False\",\n \"def minNumberOfSemesters(self, n: int, dependencies: List[List[int]], k: int) -> int:\\n\\n @lru_cache(None)\\n def dp(status, take, avaliable):\\n if status == target: # all taken\\n return 0\\n bin_take = bin(take)[2:][::-1]\\n for i,v in enumerate(bin_take):\\n if v == '1':\\n for j in edges[i]: # the indegree number changed during recursion\\n indegree[j] -= 1\\n if indegree[j] == 0:\\n avaliable |= (1 << j)\\n status |= (1 << i)\\n # print('i, status', i, v, bin(status))\\n # take -= (1 << i)\\n\\n lst = [i for i,v in enumerate(bin(avaliable)[2:][::-1]) if v == '1']\\n # print(indegree)\\n # print(lst)\\n if not lst:\\n res = 0\\n # print('lst', lst, k)\\n elif len(lst) <= k:\\n res = dp(status, avaliable, 0)\\n else:\\n res = float('inf')\\n for comb in combinations(lst, k):\\n # print(comb)\\n t, a = 0, avaliable\\n for d in comb:\\n t |= (1 << d)\\n a -= (1 << d)\\n res = min(res, dp(status, t, a))\\n for i,v in enumerate(bin_take):\\n if v == '1':\\n for j in edges[i]: \\n indegree[j] += 1\\n return 1 + res\\n\\n self.counts = 0\\n edges = defaultdict(list)\\n indegree = Counter()\\n for i,j in dependencies:\\n edges[i].append(j)\\n indegree[j] += 1\\n\\n courses = set(range(1, n+1))\\n start = courses - indegree.keys()\\n target = 2**(n+1) - 1\\n avaliable = 0\\n for i in start:\\n avaliable |= (1 << i)\\n\\n return dp(1, 0, avaliable) - 1# first dp not take courses\",\n \"def test_teleport_waltz_basis_gates(self):\\n shots = 2000\\n circuits = ref_algorithms.teleport_circuit()\\n targets = ref_algorithms.teleport_counts(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='u1,u2,u3,cx')\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)\",\n \"def spotlessroomba_third_heuristic(state : SpotlessRoombaState) -> float:\\n h = 0\\n current_position = state.position\\n dirty_locations = list(state.dirty_locations)\\n partial_heuristic = INF\\n closest_dirty = 0\\n\\n while dirty_locations:\\n for i in range(len(dirty_locations)):\\n manhattan = abs(current_position.row - dirty_locations[i].row) + abs(current_position.col - dirty_locations[i].col)\\n if manhattan < partial_heuristic:\\n partial_heuristic = manhattan\\n closest_dirty = i\\n h += partial_heuristic\\n current_position = dirty_locations.pop(closest_dirty)\\n partial_heuristic = INF\\n \\n return h\",\n \"def part1(problem_input: Iterable[str]) -> int:\\n blueprints: dict[int, tuple[RobotCost, RobotCost, RobotCost, RobotCost]] = {}\\n for s in problem_input:\\n num = re.search(r\\\"Blueprint (\\\\d+):\\\", s)[1] # type: ignore\\n r_r = re.search(r\\\"Each ore robot costs (\\\\d+) ore.\\\", s)[1] # type: ignore\\n c_r = re.search(r\\\"Each clay robot costs (\\\\d+) ore.\\\", s)[1] # type: ignore\\n _, b_r, b_c = re.search(r\\\"Each obsidian robot costs (\\\\d+) ore and (\\\\d+) clay.\\\", s) # type: ignore\\n _, g_r, g_b = re.search(r\\\"Each geode robot costs (\\\\d+) ore and (\\\\d+) obsidian.\\\", s) # type: ignore\\n blueprints[int(num)] = (\\n RobotCost(int(r_r), 0, 0),\\n RobotCost(int(c_r), 0, 0),\\n RobotCost(int(b_r), int(b_c), 0),\\n RobotCost(int(g_r), 0, int(g_b)),\\n )\\n\\n def max_geodes_harvested(blueprint: int, time: int) -> int:\\n orebot_cost, claybot_cost, obsidianbot_cost, geodebot_cost = blueprints[\\n blueprint\\n ]\\n initial_state = EconomicState(0, 0, 0, 0, 1, 0, 0, 0)\\n end_states = set([initial_state])\\n for t in range(time):\\n print(f\\\"{blueprint} {t}..\\\")\\n future_states: set[EconomicState] = set()\\n for s in end_states:\\n future_states.add(\\n EconomicState(\\n ore=s.ore + s.ore_robots,\\n clay=s.clay + s.clay_robots,\\n obsdian=s.obsdian + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots,\\n clay_robots=s.clay_robots,\\n obsdian_robots=s.obsdian_robots,\\n geode_robots=s.geode_robots,\\n )\\n )\\n if (\\n geodebot_cost.ore <= s.ore\\n and geodebot_cost.clay <= s.clay\\n and geodebot_cost.obsdian <= s.obsdian\\n ):\\n future_states.add(\\n EconomicState(\\n ore=s.ore - geodebot_cost.ore + s.ore_robots,\\n clay=s.clay - geodebot_cost.clay + s.clay_robots,\\n obsdian=s.obsdian\\n - geodebot_cost.obsdian\\n + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots,\\n clay_robots=s.clay_robots,\\n obsdian_robots=s.obsdian_robots,\\n geode_robots=s.geode_robots + 1,\\n )\\n )\\n if (\\n obsidianbot_cost.ore <= s.ore\\n and obsidianbot_cost.clay <= s.clay\\n and obsidianbot_cost.obsdian <= s.obsdian\\n ):\\n future_states.add(\\n EconomicState(\\n ore=s.ore - obsidianbot_cost.ore + s.ore_robots,\\n clay=s.clay - obsidianbot_cost.clay + s.clay_robots,\\n obsdian=s.obsdian\\n - obsidianbot_cost.obsdian\\n + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots,\\n clay_robots=s.clay_robots,\\n obsdian_robots=s.obsdian_robots + 1,\\n geode_robots=s.geode_robots,\\n )\\n )\\n if (\\n claybot_cost.ore <= s.ore\\n and claybot_cost.clay <= s.clay\\n and claybot_cost.obsdian <= s.obsdian\\n ):\\n future_states.add(\\n EconomicState(\\n ore=s.ore - claybot_cost.ore + s.ore_robots,\\n clay=s.clay - claybot_cost.clay + s.clay_robots,\\n obsdian=s.obsdian - claybot_cost.obsdian + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots,\\n clay_robots=s.clay_robots + 1,\\n obsdian_robots=s.obsdian_robots,\\n geode_robots=s.geode_robots,\\n )\\n )\\n if (\\n orebot_cost.ore <= s.ore\\n and orebot_cost.clay <= s.clay\\n and orebot_cost.obsdian <= s.obsdian\\n ):\\n future_states.add(\\n EconomicState(\\n ore=s.ore - orebot_cost.ore + s.ore_robots,\\n clay=s.clay - orebot_cost.clay + s.clay_robots,\\n obsdian=s.obsdian - orebot_cost.obsdian + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots + 1,\\n clay_robots=s.clay_robots,\\n obsdian_robots=s.obsdian_robots,\\n geode_robots=s.geode_robots,\\n )\\n )\\n end_states = future_states\\n if t > 20:\\n high_score = max(s.geodes for s in end_states)\\n if high_score > 0:\\n end_states = set(s for s in end_states if s.geodes > high_score * 0.67)\\n return max(s.geodes for s in end_states)\\n\\n return sum(n * max_geodes_harvested(n, 24) for n in blueprints.keys())\",\n \"def isSolvable(state):\\n\\n invCount = 0\\n size = len(state)\\n for i in range(0, size-1):\\n for j in range(i+1, size):\\n if (int(state[j]) and int(state[i]) and state[i] > state[j]):\\n invCount += 1\\n # return (invCount%2 == 0)\\n return 1\",\n \"def problem2(self, s):\\n \\n points = self.neighbor(100, 10, s.exhaustive_search)\\n points += self.neighbor(10, 100, s.exhaustive_search)\\n points += 1\\n\\n _testDriver.get_code(s.exhaustive_search)\\n print \\\"\\\\n(Check that scipy.spatial.KDTree is not used)\\\"\\n points *= self.grade(1)\\n\\n return points\",\n \"def final_hop(count, final_set, last_iteration, distances):\\n res = list()\\n\\n for j in range(1, count):\\n cj0 = distances[j][0] # cost of final hop of tour\\n # min-cost from 0 to j, visiting everybody once +\\n index_j = bits.generate_index(final_set, count, j)\\n res.append(last_iteration[index_j] + cj0)\\n return min(res)\",\n \"def alphabeta_search(state):\\r\\n \\r\\n '''\\r\\n Terminates when game.actions is empty\\r\\n Class Game needs the following functions:\\r\\n - game.result(state, a) -- successor\\r\\n - game.actions(state) -- possible moves\\r\\n - game.utility -- returns the state of the game (win/lose or tie, when game is terminal)\\r\\n \\r\\n '''\\r\\n #sort state.actions in increasing or decreasing based on max or min (alpha or beta)\\r\\n #use heuristics fn to get a value for each move (move is in format (x,y) where x and y are ints\\r\\n \\r\\n d = depthset[0] #this is the cutoff test depth value. if we exceed this value, stop\\r\\n cutoff_test=None\\r\\n sort_fn = [vitalpoint, eyeHeur]\\r\\n eval_fn = survivalheur \\r\\n #randnumheuristics \\r\\n player = state.to_move()\\r\\n prune = 0\\r\\n pruned = {} #this will store the depth of the prune\\r\\n totaldepth = [0]\\r\\n visited = {}\\r\\n heuristicInd = 0\\r\\n \\r\\n def max_value(state, alpha, beta, depth, heuristicInd):\\r\\n branches = len(state.actions())\\r\\n onbranch = 0\\r\\n \\r\\n if totaldepth[0] < depth:\\r\\n totaldepth[0] = depth\\r\\n if cutoff_test(state, depth):\\r\\n return eval_fn(state)\\r\\n v = -infinity\\r\\n \\r\\n #sort state.actions based on heuristics before calling\\r\\n #max wants decreasing\\r\\n #sorted(state.actions(), key = eval_sort, reverse = True)\\r\\n \\r\\n #sort by favorites first, returns a list of actions\\r\\n # for sorts in sort_fn:\\r\\n tempher = heuristicInd\\r\\n\\r\\n sorts = sort_fn[heuristicInd]\\r\\n sortedactions, heuristicInd = sorts(state)\\r\\n #if heuristicInd != tempher:\\r\\n # print 's',\\r\\n ''''''\\r\\n for a in sortedactions:\\r\\n if visited.get(depth) == None:\\r\\n visited[depth] = [a]\\r\\n else:\\r\\n visited[depth].append(a)\\r\\n \\r\\n onbranch += 1\\r\\n v = max(v, min_value(state.result(a),\\r\\n alpha, beta, depth+1, heuristicInd)) #+ vitscore.count(a)\\r\\n if v >= beta: #pruning happens here, but in branches\\r\\n if pruned.get(depth) == None:\\r\\n pruned[depth] = branches - onbranch\\r\\n else:\\r\\n pruned[depth] += (branches - onbranch)\\r\\n #print \\\"prune\\\", depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n return v\\r\\n alpha = max(alpha, v)\\r\\n \\r\\n #print depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n \\r\\n return v\\r\\n\\r\\n def min_value(state, alpha, beta, depth, heuristicInd):\\r\\n branches = len(state.actions())\\r\\n onbranch = 0\\r\\n \\r\\n if totaldepth[0] < depth:\\r\\n totaldepth[0] = depth\\r\\n if cutoff_test(state, depth):\\r\\n return eval_fn(state)\\r\\n v = infinity\\r\\n \\r\\n #sort state.actions based on heuristics before calling\\r\\n #min wants increasing\\r\\n #sorted(state.actions(), key = eval_sort)\\r\\n #Shayne\\r\\n tempher = heuristicInd\\r\\n sorts = sort_fn[heuristicInd]\\r\\n sortedactions, heuristicInd = sorts(state, 1)\\r\\n #if heuristicInd != tempher:\\r\\n # print 's',\\r\\n for a in sortedactions: #state.actions():\\r\\n onbranch += 1\\r\\n if visited.get(depth) == None:\\r\\n visited[depth] = [a]\\r\\n else:\\r\\n visited[depth].append(a)\\r\\n v = min(v, max_value(state.result(a),\\r\\n alpha, beta, depth+1, heuristicInd))\\r\\n if v <= alpha: #pruning happens here, but in branches\\r\\n if pruned.get(depth) == None:\\r\\n pruned[depth] = branches - onbranch\\r\\n else:\\r\\n pruned[depth] += (branches - onbranch)\\r\\n #print \\\"prune\\\", depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n return v\\r\\n beta = min(beta, v)\\r\\n #print depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n return v\\r\\n\\r\\n # Body of alphabeta_search starts here:\\r\\n #def cutoff_test and eval_fn \\r\\n cutoff_test = (cutoff_test or\\r\\n (lambda state,depth: depth>d or state.terminal_test()))\\r\\n eval_fn = eval_fn or (lambda state: state.utility(player))\\r\\n #by default, utility score is used\\r\\n \\r\\n \\r\\n #argmax goes through all the possible actions and \\r\\n # applies the alphabeta search onto all of them\\r\\n # and returns the move with the best score \\r\\n #print state.actions()\\r\\n heuristicInd = 0\\r\\n sorts = sort_fn[heuristicInd]\\r\\n sortedact, heuristicInd = sorts(state)\\r\\n abmove = argmax(sortedact,\\r\\n lambda a: min_value(state.result(a),\\r\\n -infinity, infinity, 0, heuristicInd))\\r\\n\\r\\n print 'problem,', problemno[0], ', total tree depth,', totaldepth[0]\\r\\n for i in range(1, len(visited)):\\r\\n if len(pruned) < i:\\r\\n pruned[i] = 0\\r\\n print i, \\\",\\\", len(visited[i]), \\\",\\\", pruned[i]\\r\\n \\r\\n return abmove\",\n \"def day_03_b() -> int:\\n instructions = read_instructions('aoc/aoc2015/input/03A.txt')\\n santa_instructions = ''.join(w for i, w in enumerate(instructions) if is_odd(i))\\n robo_instructions = ''.join(w for i, w in enumerate(instructions) if is_even(i))\\n\\n santa_houses = get_visited_houses(santa_instructions)\\n robo_houses = get_visited_houses(robo_instructions)\\n\\n return len(merge_dicts(santa_houses, robo_houses))\",\n \"def safeJourney(Alist,s,d):\\n #Initialize dictionaries\\n dinit = 10**6\\n Edict = {} #Explored nodes\\n Udict = {} #Unexplored nodes\\n path = [[] for l in Alist]\\n\\n Alen = len(Alist) #length of Alist\\n dinits = [dinit]*Alen #list of airport indexes\\n Udict = dict(zip(list(range(Alen)),dinits)) #zip into dictionary\\n Udict[s] = 0\\n path[s] = [s]\\n \\n #Main search\\n while len(Udict)>0:\\n #Find node with min d in Udict and move to Edict\\n dmin = dinit\\n for n,w in Udict.items():\\n if w<dmin:\\n dmin=w\\n nmin=n\\n Edict[nmin] = Udict.pop(nmin)\\n print(\\\"moved node\\\", nmin)\\n\\n #Update provisional distances for unexplored neighbors of nmin\\n \\n #for n,w in G.adj[nmin].items():\\n for item in Alist[nmin]: #nminth element is a list of two element tuples (node, weight)\\n n = item[0] #first elt of tuple is node/neighbour\\n w = item[1] #2nd elt is density/weigh\\n #for n,w in etc_______________________-\\n \\n if n in Edict:\\n pass\\n elif n in Udict:\\n #dcomp = dmin + w\\n dcomp = max(w,dmin) #take largest value to record most dangerous segment\\n if dcomp<Udict[n]:\\n print(Udict)\\n Udict[n]=dcomp\\n path[n] = path[nmin] + [n]\\n #path[n].extend(path[nmin])\\n #path[n] = path[nmin]\\n \\n #path[n].append(n) #n not nmin\\n print(path)\\n # else:\\n #dcomp = dmin + w\\n # dcomp = max(w,dmin)\\n # Udict[n] = dcomp\\n #path[n].extend(path[nmin])\\n #path[n].append(nmin) \\n \\n if nmin == d: #if current node is destination\\n return path[d],Edict[d]\\n return [] #no path\",\n \"def genRandTeam(nPos, totPlayers):\\n # 0 1 2 3 4 5 6\\n # nPos = [nFirst, nSecond, nThird, nShort, nCatcher, nOf, nDh]\\n chromosome = []\\n sum = 0\\n count = 0\\n\\n\\n for i in nPos: # general loop\\n if count == 6: # when loop enters the nDh players it instead chooses from ALL positions five times\\n for j in range(5): # to represent the 2 util positions and the 3 benches\\n rNum = random.randint(0, totPlayers - 1) # random number of ANY player\\n chromosome.append(rNum) # picks a random pos\\n break # no more work needs to be done\\n if count == 5: # this will occur before the previous loop; nOF must be iterated 3 times for 3 outfield spots\\n for j in range(2):\\n rNum2 = random.randint(0, i - 1)\\n chromosome.append(rNum2 + sum) # nOF must be iterated 3 times for 3 outfield spots; i is on oF\\n rNum3 = random.randint(0, i - 1)\\n chromosome.append(rNum3 + sum)\\n sum += i\\n count += 1\\n # first = random.randint(0,nPos[0])\\n # second = random.randint(0,nPos[1])\\n # third = random.randint(0,nPos[2])\\n # short = random.randint(0,nPos[3])\\n # catcher = random.randint(0,nPos[4])\\n # of = [random.randint(0,nPos[5]), random.randint(0,nPos[5]), random.randint(0,nPos[5])] #THREE outfielders\\n # rNum = [random.randint(0,6) for i in range(5)] #random numbers representing one of the nPos rosters\\n # util = [random.randint(0,nPos[rNum[0]]), random.randint(0,nPos[rNum[1]])] #picks 2 random players from ANY roster\\n # ben = [random.randint(0,nPos[rNum[2]]), random.randint(0,nPos[rNum[3]]), random.randint(0,nPos[rNum[4]])] # picks 3 random players form any roster\\n # print first,second,third,short,catcher,of,util,ben\\n # temp = Team()\\n return chromosome\",\n \"def spreadOutAndFindDot(self, gameState):\\n # Here are some useful elements of the startState\\n currentPosition = gameState.getPacmanPosition(self.index)\\n foodList = gameState.getFood().asList()\\n walls = gameState.getWalls()\\n randomFood = []\\n problem = []\\n\\n #problem = AnyFoodSearchProblem(gameState, self.index)\\n\\n # if min(manhattan(currentPosition, foodPosition) for foodPosition in food.asList()) > 10:\\n # return [Directions.STOP]\\n #print(\\\"self.targets = \\\", self.targets)\\n if self.index == 0:\\n TargetFood = ClosestFood(currentPosition, foodList)\\n #self.targets.append(TargetFood)\\n problem = PositionSearchProblem(gameState, 0, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\\n return search.aStarSearch(problem, manhattanHeuristic)\\n if self.index == 1:\\n TargetFood = ClosestFood(currentPosition, foodList)\\n \\\"\\\"\\\"\\n want to find a way to avoid both agents coming up with the same target. But the below doesn't work because\\n each agent has their own self.targets. How to keep a common list of targets?\\n \\\"\\\"\\\"\\n # if TargetFood in self.targets:\\n # tempFoodList = foodList.copy()\\n # tempFoodList.pop(tempFoodList.index(TargetFood))\\n # TargetFood = ClosestFood(currentPosition, tempFoodList)\\n # self.targets.append(TargetFood)\\n # else:\\n # self.targets.append(TargetFood)\\n problem = PositionSearchProblem(gameState, 1, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\\n return search.aStarSearch(problem, manhattanHeuristic)\\n if self.index == 2:\\n TargetFood = RandomFood(currentPosition, foodList)\\n problem = PositionSearchProblem(gameState, 2, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\\n return search.aStarSearch(problem, manhattanHeuristic)\\n if self.index == 3:\\n TargetFood = RandomFood(currentPosition, foodList)\\n problem = PositionSearchProblem(gameState, 3, goal=TargetFood, start=currentPosition, warn=False, visualize=False)\\n return search.aStarSearch(problem, manhattanHeuristic)\\n #return search.bfs(problem)\\n\\n #util.raiseNotDefined()\",\n \"def sea_execution(board, position, role):\\n quitt = False\\n if position == 'comp':\\n #print(1)\\n #temporary for dumb AI\\n #create and print a list of coastal, friendly regions where norse is not the ONLY one\\n \\n possible_region_list = []\\n \\n #loops through list of friendly, coastal, not just Norse regions to append to a possible_region_list\\n for region in board.get_controlled_regions(role):\\n #print(2)\\n coastal = False\\n just_norse = False\\n if region.coast:\\n coastal = True\\n if len(region.blocks_present) == 1 and region.blocks_present[0].name.upper() == 'NORSE':\\n just_norse = True\\n \\n if coastal and not just_norse:\\n possible_region_list.append(region)\\n \\n \\n #loops through list of friendly, coastal regions to append to a possible_final_region_list\\n possible_final_region_list = []\\n for region in board.get_controlled_regions(role): \\n #print(3) \\n if region.coast:\\n possible_final_region_list.append(region)\\n \\n \\n \\n if len(possible_final_region_list) >= 2:\\n #if you want to add in last-min strategy, do it here\\n #random region from possible list\\n england = board.regions[22]\\n if england in possible_region_list:\\n original_region = england\\n else:\\n original_region = possible_region_list[random.randint(0, len(possible_region_list) - 1)]\\n #remove the original region from the possible end regions\\n possible_final_region_list.remove(original_region)\\n \\n #possible_block_list\\n #list of possible blocks to move (present in region) and not norse\\n possible_block_list = []\\n for block in original_region.blocks_present:\\n if block.name != 'NORSE':\\n possible_block_list.append(block)\\n \\n move_block_list = []\\n blocks_moved = 0\\n #print(4)\\n\\n while blocks_moved < 2:\\n #print(5)\\n block = possible_block_list[random.randint(0, len(possible_block_list)-1)]\\n #if it's not already on the list,append to move_block_list\\n if block not in move_block_list:\\n move_block_list.append(block)\\n blocks_moved+=1\\n elif block in move_block_list and len(possible_block_list) == 1:\\n blocks_moved+=1\\n else:\\n print('neither condition was met so this is an infinite loop')\\n \\n \\n #print(6) \\n new_region = possible_final_region_list[random.randint(0, len(possible_final_region_list) - 1)]\\n \\n for block in move_block_list:\\n \\n board.add_to_location(block, new_region)\\n print(block.name + ' moved from ' + original_region.name + ' to ' + new_region.name)\\n \\n else:\\n print('There are not enough friendly regions with which to play this card.')\\n \\n \\n #add in if it's not possible\\n elif position == 'opp':\\n \\n \\n possible_region_list = []\\n \\n #loops through list of friendly, coastal, not just Norse regions to append to a possible_region_list\\n for region in board.get_controlled_regions(role):\\n coastal = False\\n just_norse = False\\n if region.coast:\\n coastal = True\\n if len(region.blocks_present) == 1 and region.blocks_present[0].name.upper() == 'NORSE':\\n just_norse = True\\n \\n if coastal and not just_norse:\\n possible_region_list.append(region)\\n \\n \\n #loops through list of friendly, coastal regions to append to a possible_final_region_list\\n possible_final_region_list = []\\n for region in board.get_controlled_regions(role): \\n if region.coast:\\n possible_final_region_list.append(region)\\n \\n \\n \\n if len(possible_final_region_list) >= 2:\\n \\n print('Possible origin regions:')\\n for region in possible_region_list:\\n print(region.name)\\n \\n #user input region, check if in possible list\\n valid_region = False\\n while not valid_region:\\n \\n original_region_name = input('What region would you like to move block(s) from? Enter a name or \\\\'none\\\\'.\\\\n>').upper()\\n \\n if original_region_name != 'NONE':\\n \\n original_region = search.region_name_to_object(board, original_region_name)\\n \\n if original_region and original_region in possible_region_list:\\n valid_region = True\\n else:\\n print('Invalid region.')\\n else:\\n quitt = True\\n \\n if not quitt:\\n #remove the original region from the possible end regions\\n possible_final_region_list.remove(original_region)\\n \\n #possible_block_list\\n #list of possible blocks to move (present in region) and not norse\\n possible_block_list = []\\n for block in original_region.blocks_present:\\n if block.name != 'NORSE':\\n possible_block_list.append(block)\\n \\n print('Possible blocks:')\\n for block in possible_block_list:\\n print(block.name)\\n \\n \\n move_block_list = []\\n blocks_moved = 0\\n quittt = False\\n block_name = ''\\n while blocks_moved < 2 and not quittt:\\n if block_name != 'NONE':\\n valid_block = False\\n while not valid_block:\\n \\n \\n block_name = input('Which block would you like to move? Enter a name or \\\\'none\\\\'.\\\\n>').upper()\\n \\n if block_name != 'NONE':\\n \\n block_to_move = search.block_name_to_object(possible_block_list, block_name)\\n \\n if block_to_move and block_to_move not in move_block_list:\\n valid_block = True\\n move_block_list.append(block_to_move)\\n blocks_moved+=1\\n \\n elif block in move_block_list and len(possible_block_list) == 1:\\n blocks_moved=1\\n \\n else:\\n print('Invalid block.')\\n continue\\n else:\\n valid_block = True\\n if len(move_block_list) == 1:\\n quittt = True\\n quitt = False\\n if len(move_block_list) > 0: \\n print('Possible final regions:')\\n for region in possible_final_region_list:\\n print(region.name)\\n \\n #user input region, check if in possible list\\n valid_region = False\\n while not valid_region:\\n \\n new_region_name = input('What region would you like to move block(s) to? Enter a name or \\\\'none\\\\'.\\\\n>').upper()\\n \\n if new_region_name != 'NONE':\\n \\n new_region = search.region_name_to_object(board, new_region_name)\\n \\n if new_region and new_region in possible_final_region_list:\\n valid_region = True\\n else:\\n print('Invalid region.')\\n continue\\n else:\\n valid_region = True\\n quitt = True\\n \\n if not quitt:\\n \\n for block in move_block_list:\\n \\n board.add_to_location(block, new_region)\\n print(block.name + ' moved from ' + original_region.name + ' to ' + new_region.name)\\n \\n else:\\n print('There are not enough friendly coastal regions with which to play this card.')\",\n \"def get_high_one(self, state):\\n non_zero_idxs = [-2, -3, -4]\\n idx_idxs = np.random.randint(low=0, high=3, size=10)\\n for idx_idx in idx_idxs:\\n non_zero_idx = non_zero_idxs[idx_idx]\\n if self.potential(state) + self.weights[non_zero_idx] <= self.initial_potential:\\n state[non_zero_idx] += 1\\n break\\n return state\",\n \"def find_initial_betas(self):\\n if self.verbose >= 2:\\n print(\\\"\\\\r{}\\\\rFinding initial betas\\\".format(' ' * 80), end='', file=sys.stderr)\\n # Find ranges of states for each CRE\\n Tranges = numpy.zeros((self.rna.shape[0], 2), dtype=numpy.int32)\\n for i in range(self.rna_indices.shape[0] - 1):\\n s = self.rna_indices[i]\\n e = self.rna_indices[i + 1]\\n if e - s == 0:\\n continue\\n s1 = self.state_indices[i]\\n e1 = self.state_indices[i + 1]\\n if e1 - s1 == 0:\\n continue\\n starts = numpy.searchsorted(self.state['end'][s1:e1],\\n self.rna['TSS'][s:e] - self.initialization_dist,\\n #* numpy.logical_not(self.rna['strand'][s:e]),\\n side='right') + s1\\n stops = numpy.searchsorted(self.state['start'][s1:e1],\\n self.rna['TSS'][s:e] + self.initialization_dist,\\n #* self.rna['strand'][s:e],\\n side='left') + s1\\n Tranges[s:e, 0] = starts\\n Tranges[s:e, 1] = stops\\n # Divide list across multiple processes\\n tss_queue = multiprocessing.JoinableQueue()\\n results_queue = multiprocessing.JoinableQueue()\\n processes = []\\n for i in range(self.threads):\\n processes.append(multiprocessing.Process(\\n target=self._assign_promoter_state, args=(tss_queue, results_queue, Tranges,\\n self.initialization_dist,\\n self.rng.randint(99999), True)))\\n processes[-1].daemon = True\\n processes[-1].start()\\n step = int(self.rna_indices[-1] / max(self.threads, 1) / 4.)\\n for i in range(self.rna_indices.shape[0] - 1):\\n for j in range(self.rna_indices[i], self.rna_indices[i + 1], step):\\n stop = min(self.rna_indices[i + 1], j + step)\\n tss_queue.put((j, stop))\\n for i in range(self.threads):\\n tss_queue.put(None)\\n # Even though there may be multiple reps for a celltype, we only find the average state proportion across reps\\n Tstates = numpy.zeros((self.rna.shape[0], self.cellN, self.stateN), dtype=numpy.float32)\\n finished = 0\\n while finished < self.threads:\\n results = results_queue.get(True)\\n if results is None:\\n finished += 1\\n continue\\n start, stop = results[:2]\\n Tstates[start:stop, :, :] = results[2]\\n Tstates2 = numpy.copy(Tstates)\\n Tstates = Tstates[:, self.lmask, :]\\n Tstates /= numpy.sum(Tstates, axis=2, keepdims=True)\\n betas = numpy.linalg.lstsq(Tstates.reshape(-1, Tstates.shape[2], order='C'),\\n self.rna['rna'][:, self.lmask].reshape(-1, order='C'),\\n rcond=None)[0]\\n self.initial_betas = betas\\n if self.verbose >= 2:\\n print(\\\"\\\\r{}\\\\r\\\".format(' ' * 80), end='', file=sys.stderr)\",\n \"def __find_all_moves(self, tower) -> list:\\r\\n choice = []\\r\\n for height in range(1,len(tower.tower)-2):\\r\\n for index in range(1,4):\\r\\n if self.stat_brain.is_valid(height, index, tower):\\r\\n choice.append((height, index))\\r\\n \\r\\n r.shuffle(choice)\\r\\n return choice\",\n \"def calculateOptimal(self) -> (list, int):\\n\\t\\tcombinations = list(itertools.product(*self.clusters))\\n\\t\\tmin_dist = 1000000\\n\\t\\tmin_combination = None\\n\\t\\tfor combination in combinations:\\n\\t\\t\\tdist = super().step(combination)\\n\\t\\t\\tif(dist < min_dist):\\n\\t\\t\\t\\tmin_dist = dist\\n\\t\\t\\t\\tmin_combination = combination\\n\\t\\treturn (min_combination, min_dist)\",\n \"def test_teleport_default_basis_gates(self):\\n shots = 2000\\n circuits = ref_algorithms.teleport_circuit()\\n targets = ref_algorithms.teleport_counts(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)\",\n \"def __find_random_moves(self, tower) -> int:\\r\\n while True:\\r\\n height, index = r.randint(1, len(tower.tower)-1), r.randint(1,3)\\r\\n if tower.tower[height-1].blocks[index-1] == 1:\\r\\n return height, index\",\n \"def split_candy(case):\\n\\n s_best_sum = 0\\n\\n# print case\\n if len(case) <= 1:\\n return \\\"NO\\\"\\n\\n # annotate values to protect against duplicates\\n annotated_case = [ (i, x) for i,x in enumerate(case) ]\\n# print annotated_case\\n\\n for length in range(1, len(annotated_case)):\\n for s_pile in itertools.combinations(annotated_case, length):\\n p_pile = set(annotated_case).difference(s_pile)\\n\\n # unzip\\n s_pile = zip(*s_pile)[1]\\n p_pile = zip(*p_pile)[1]\\n\\n# print s_pile, p_pile\\n\\n s_sum = reduce(lambda x, y: x+y, s_pile)\\n s_xor = reduce(lambda x, y: x^y, s_pile)\\n p_xor = reduce(lambda x, y: x^y, p_pile)\\n\\n# print s_pile, s_sum, s_xor, p_pile, p_xor\\n if s_xor == p_xor:\\n# print \\\"match\\\"\\n s_best_sum = max(s_sum, s_best_sum)\\n\\n return s_best_sum or \\\"NO\\\"\",\n \"def checkNumNeighbors():\",\n \"def buyable(n: int) -> bool:\\n if n in [4, 6, 25]:\\n return True\\n elif n < 4:\\n return False\\n else:\\n buyability = False\\n for size in [4, 6, 25]:\\n buyability |= buyable(n - size)\\n return buyability\",\n \"def get_heurisitc_cost_stacks(element, stack_index, goal_state, unused_stacks, unused_index):\\n for k,v in goal_state.items():\\n if element in v:\\n return (abs(stack_index - k), v.index(element))\\n if stack_index in unused_stacks:\\n return (0, -1)\\n else:\\n return (abs(unused_index - stack_index), -1)\",\n \"def gene_finder(dna):\\n orfs = find_all_ORFs_both_strands(dna)\\n print(orfs)\\n threshold = longest_ORF_noncoding(dna, 1000)\\n print('threshold is', threshold)\\n print('number of orfs:', len(orfs))\\n aa_sequences = []\\n i = 0\\n while i < len(orfs):\\n print(len(orfs[i]))\\n if len(orfs[i]) > threshold:\\n print('if')\\n aa_sequences += [coding_strand_to_AA(orfs[i])]\\n i += 1\\n print(aa_sequences)\",\n \"def four_stools_hanoi(n, first_stool, second_stool, third_stool, fourth_stool):\\n if n == 1:\\n return [(first_stool, fourth_stool)]\\n else:\\n i = find_i(n)\\n a = four_stools_hanoi(n - i, first_stool, third_stool, fourth_stool,\\n second_stool)\\n b = three_stools_hanoi(i, first_stool, third_stool, fourth_stool)\\n c = four_stools_hanoi(n - i, second_stool, third_stool, first_stool,\\n fourth_stool)\\n return a + b + c\",\n \"def find_all_ORFs_oneframe(dna):\",\n \"def _check_sonar_obstacles(self):\\n # TODO: what's a good number?\\n BLOCKED_THRESHOLD = 0.7\\n\\n rate = rospy.Rate(10) # 10 hz\\n count = 10\\n left = 0\\n center = 0\\n right = 0\\n\\n for i in range(count):\\n obstacle = self.swarmie.get_obstacle_condition()\\n\\n if obstacle & Obstacle.SONAR_LEFT == Obstacle.SONAR_LEFT:\\n left += 1\\n if (obstacle & Obstacle.SONAR_CENTER ==\\n Obstacle.SONAR_CENTER):\\n center += 1\\n if obstacle & Obstacle.SONAR_RIGHT == Obstacle.SONAR_RIGHT:\\n right += 1\\n\\n rate.sleep()\\n\\n left_blocked = left / count > BLOCKED_THRESHOLD\\n center_blocked = center / count > BLOCKED_THRESHOLD\\n right_blocked = right / count > BLOCKED_THRESHOLD\\n\\n return left_blocked, center_blocked, right_blocked\",\n \"def findAstromCorrs(self):\\n self.logfile.write(\\\"Entered findAstromCorrs - will run: \\\"+\\\\\\n \\\"makeGSCcat(), makeObjcats(), doMatching().\\\")\\n\\n if self.makeGSCcat() != 0:\\n return -1\\n if self.makeObjcats()!= 0:\\n return -1\\n if self.doMatching() != 0:\\n # here we want to remake the GSCcat using a \\\"chopSpur\\\" flag,\\n # if the cat has a goodly number of objects\\n if(self.Ncull >= 10):\\n print \\\"Retrying matchup with only GSC objs detected in 2 bands...\\\"\\n self.logfile.write(\\\"Retrying matchup with only GSC objs detected in 2 bands...\\\")\\n if self.makeGSCcat(chopSpur=1) != 0:\\n return -1\\n if self.makeObjcats()!= 0:\\n return -1\\n if self.doMatching() != 0:\\n return -1\\n\\n return 0\",\n \"def find_best_k(data, anots, neibhours_range):\\r\\n \\r\\n best_k = 0\\r\\n best_acc = 0\\r\\n for n_neighbors in neibhours_range:\\r\\n accur = iterate_over_chanels(data, anots, n_neighbors)\\r\\n mean_acc = accur.mean()\\r\\n if mean_acc > best_acc:\\r\\n best_acc = mean_acc\\r\\n best_k = n_neighbors\\r\\n return best_k\",\n \"def count_ways(n):\\n if n < 0:\\n return 0\\n elif n == 0:\\n return 1\\n else:\\n total = 0\\n for i in range(1, min(n, 3) + 1):\\n total += count_ways(n - i)\\n return total\",\n \"def spawn_ok(game):\\n me = game.me\\n shipyard_cell = game.game_map[me.shipyard]\\n\\n # % turns above mining rate to dropoff the halite, will typically be about 2?\\n mining_over_head = 2\\n ship_count = len(me.get_ships())\\n\\n #\\n # absolute constraints (order can be important)\\n #\\n\\n if ship_count >= MAX_SHIPS:\\n if DEBUG & (DEBUG_GAME): logging.info(\\\"Game - Spawn denied. MAX ships reached\\\".format())\\n return False\\n\\n if me.halite_amount < constants.SHIP_COST:\\n if DEBUG & (DEBUG_GAME): logging.info(\\\"Game - Spawn denied. Insufficient halite\\\".format())\\n return False\\n\\n #\\n # conditional constraints\\n #\\n\\n logging.debug(\\\"shipyard_cell.is_occupied: {}\\\".format(shipyard_cell.is_occupied))\\n if shipyard_cell.is_occupied:\\n logging.debug(\\\"shipyard_cell.ship.owner == me.id: {}\\\".format(shipyard_cell.ship.owner == me.id))\\n\\n # watch for collisions with owner only, note this will be 1 turn behind\\n occupied_cells = []\\n if shipyard_cell.is_occupied and shipyard_cell.ship.owner == me.id:\\n occupied_cells.append(shipyard_cell.position)\\n\\n logging.debug(\\\"oc1: {}\\\".format(occupied_cells))\\n\\n # entry lane are N/S\\n n_cell = shipyard_cell.position.directional_offset(Direction.North)\\n s_cell = shipyard_cell.position.directional_offset(Direction.South)\\n e_cell = shipyard_cell.position.directional_offset(Direction.East)\\n w_cell = shipyard_cell.position.directional_offset(Direction.West)\\n for pos in [n_cell, s_cell, e_cell, w_cell]:\\n if game.game_map[pos].is_occupied:\\n occupied_cells.append(pos)\\n\\n logging.debug(\\\"oc2: {}\\\".format(occupied_cells))\\n\\n # need to keep track of ships docking instead, a ship in an adjacent cell could be leaving\\n if occupied_cells:\\n if DEBUG & (DEBUG_GAME): logging.info(\\\"Game - Spawn denied. Occupied cells: {}\\\".format(occupied_cells))\\n return False\\n\\n return True\",\n \"def solution(self) -> State:\",\n \"def in_bomb_range(self, game_state: dict):\\n is_in_bomb_range = False\\n agent_position = game_state['self'][3]\\n agent_position = list(agent_position)\\n\\n for bomb in game_state['bombs']:\\n if agent_position == list(bomb[0]):\\n is_in_bomb_range = True\\n\\n for i in range(3):\\n agent_search = copy.copy(agent_position)\\n if agent_position[0] - i - 1 >= 0:\\n agent_search[0] = agent_position[0] - i - 1\\n if agent_search == list(bomb[0]):\\n is_in_bomb_range = True\\n\\n for i in range(3):\\n agent_search = copy.copy(agent_position)\\n if agent_position[0] + i + 1 <= 16:\\n agent_search[0] = agent_position[0] + i + 1\\n if agent_search == list(bomb[0]):\\n is_in_bomb_range = True\\n\\n for i in range(3):\\n agent_search = copy.copy(agent_position)\\n if agent_position[1] - i - 1 >= 0:\\n agent_search[1] = agent_position[1] - i - 1\\n if agent_search == list(bomb[0]):\\n is_in_bomb_range = True\\n\\n for i in range(3):\\n agent_search = copy.copy(agent_position)\\n if agent_position[1] + i + 1 <= 16:\\n agent_search[1] = agent_position[1] + i + 1\\n if agent_search == list(bomb[0]):\\n is_in_bomb_range = True\\n\\n # check if a stone wall is between the agent an the bomb\\n if is_in_bomb_range:\\n if agent_position[0] == list(bomb[0])[0]:\\n if agent_position[1] < list(bomb[0])[1]:\\n for i in range(agent_position[1], list(bomb[0])[1]):\\n if game_state['field'][agent_position[0]][i] == -1:\\n is_in_bomb_range = False\\n else:\\n for i in range(list(bomb[0])[1], agent_position[1]):\\n if game_state['field'][agent_position[0]][i] == -1:\\n is_in_bomb_range = False\\n elif agent_position[1] == list(bomb[0])[1]:\\n if agent_position[0] < list(bomb[0])[0]:\\n for i in range(agent_position[0], list(bomb[0])[0]):\\n if game_state['field'][i][agent_position[1]] == -1:\\n is_in_bomb_range = False\\n else:\\n for i in range(list(bomb[0])[0], agent_position[0]):\\n if game_state['field'][i][agent_position[1]] == -1:\\n is_in_bomb_range = False\\n\\n return is_in_bomb_range\",\n \"def part2(problem_input: Iterable[str]) -> int:\\n\\n blueprints: dict[int, tuple[RobotCost, RobotCost, RobotCost, RobotCost]] = {}\\n for s in problem_input:\\n num = re.search(r\\\"Blueprint (\\\\d+):\\\", s)[1] # type: ignore\\n r_r = re.search(r\\\"Each ore robot costs (\\\\d+) ore.\\\", s)[1] # type: ignore\\n c_r = re.search(r\\\"Each clay robot costs (\\\\d+) ore.\\\", s)[1] # type: ignore\\n _, b_r, b_c = re.search(r\\\"Each obsidian robot costs (\\\\d+) ore and (\\\\d+) clay.\\\", s) # type: ignore\\n _, g_r, g_b = re.search(r\\\"Each geode robot costs (\\\\d+) ore and (\\\\d+) obsidian.\\\", s) # type: ignore\\n blueprints[int(num)] = (\\n RobotCost(int(r_r), 0, 0),\\n RobotCost(int(c_r), 0, 0),\\n RobotCost(int(b_r), int(b_c), 0),\\n RobotCost(int(g_r), 0, int(g_b)),\\n )\\n\\n def max_geodes_harvested(blueprint: int, time: int) -> int:\\n orebot_cost, claybot_cost, obsidianbot_cost, geodebot_cost = blueprints[\\n blueprint\\n ]\\n initial_state = EconomicState(0, 0, 0, 0, 1, 0, 0, 0)\\n end_states = set([initial_state])\\n for t in range(time):\\n print(f\\\"{blueprint} {t}..\\\")\\n future_states: set[EconomicState] = set()\\n for s in end_states:\\n future_states.add(\\n EconomicState(\\n ore=s.ore + s.ore_robots,\\n clay=s.clay + s.clay_robots,\\n obsdian=s.obsdian + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots,\\n clay_robots=s.clay_robots,\\n obsdian_robots=s.obsdian_robots,\\n geode_robots=s.geode_robots,\\n )\\n )\\n if (\\n geodebot_cost.ore <= s.ore\\n and geodebot_cost.clay <= s.clay\\n and geodebot_cost.obsdian <= s.obsdian\\n ):\\n future_states.add(\\n EconomicState(\\n ore=s.ore - geodebot_cost.ore + s.ore_robots,\\n clay=s.clay - geodebot_cost.clay + s.clay_robots,\\n obsdian=s.obsdian\\n - geodebot_cost.obsdian\\n + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots,\\n clay_robots=s.clay_robots,\\n obsdian_robots=s.obsdian_robots,\\n geode_robots=s.geode_robots + 1,\\n )\\n )\\n if (\\n obsidianbot_cost.ore <= s.ore\\n and obsidianbot_cost.clay <= s.clay\\n and obsidianbot_cost.obsdian <= s.obsdian\\n ):\\n future_states.add(\\n EconomicState(\\n ore=s.ore - obsidianbot_cost.ore + s.ore_robots,\\n clay=s.clay - obsidianbot_cost.clay + s.clay_robots,\\n obsdian=s.obsdian\\n - obsidianbot_cost.obsdian\\n + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots,\\n clay_robots=s.clay_robots,\\n obsdian_robots=s.obsdian_robots + 1,\\n geode_robots=s.geode_robots,\\n )\\n )\\n if (\\n claybot_cost.ore <= s.ore\\n and claybot_cost.clay <= s.clay\\n and claybot_cost.obsdian <= s.obsdian\\n ):\\n future_states.add(\\n EconomicState(\\n ore=s.ore - claybot_cost.ore + s.ore_robots,\\n clay=s.clay - claybot_cost.clay + s.clay_robots,\\n obsdian=s.obsdian - claybot_cost.obsdian + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots,\\n clay_robots=s.clay_robots + 1,\\n obsdian_robots=s.obsdian_robots,\\n geode_robots=s.geode_robots,\\n )\\n )\\n if (\\n orebot_cost.ore <= s.ore\\n and orebot_cost.clay <= s.clay\\n and orebot_cost.obsdian <= s.obsdian\\n ):\\n future_states.add(\\n EconomicState(\\n ore=s.ore - orebot_cost.ore + s.ore_robots,\\n clay=s.clay - orebot_cost.clay + s.clay_robots,\\n obsdian=s.obsdian - orebot_cost.obsdian + s.obsdian_robots,\\n geodes=s.geodes + s.geode_robots,\\n ore_robots=s.ore_robots + 1,\\n clay_robots=s.clay_robots,\\n obsdian_robots=s.obsdian_robots,\\n geode_robots=s.geode_robots,\\n )\\n )\\n end_states = future_states\\n if t >= 25:\\n high_score = max(s.geodes for s in end_states)\\n if high_score > 0:\\n end_states = set(s for s in end_states if s.geodes > high_score * 0.67)\\n g = max(s.geodes for s in end_states)\\n print(f\\\"{blueprint} >>>{g}<<<\\\")\\n return g\\n\\n return prod(max_geodes_harvested(n, 32) for n in [1,2,3])\",\n \"def get_n_best(self):\\n pass\",\n \"def find_all_ORFs(dna):\\n \\n # YOUR IMPLEMENTATION HERE\",\n \"def all_valid(self, tower) -> int:\\r\\n count = 0\\r\\n for layer in range(1, len(tower.tower)):\\r\\n for index in range(1, 4):\\r\\n if self.is_valid(layer, index, tower):\\r\\n count += 1\\r\\n \\r\\n return count\",\n \"def findIslands(self):\\n\\n # First lets find the shores.\\n shoreList = self.findShores()\\n\\n # Initialize Blank Values.\\n N, S, E, W = (None for i in range(4))\\n\\n # Next, we find all the furthest extremities among all shore lists.\\n # In theory, the only extremities that can occur for shorelines that\\n # Don't belong to the main pond body are along the map edge.\\n for index, shore in enumerate(shoreList):\\n extremityHash = shore.findExtremities()\\n if index == 0:\\n N, S, E, W = ([shore] for i in range(4))\\n continue\\n if extremityHash['N'][0].x < N[0].findExtremities()['N'][0].x:\\n N = [shore]\\n elif extremityHash['N'][0].x == N[0].findExtremities()['N'][0].x:\\n N.append(shore)\\n if extremityHash['S'][0].x > S[0].findExtremities()['S'][0].x:\\n S = [shore]\\n elif extremityHash['S'][0].x == S[0].findExtremities()['S'][0].x:\\n S.append(shore)\\n if extremityHash['E'][0].y > E[0].findExtremities()['E'][0].y:\\n E = [shore]\\n elif extremityHash['E'][0].y == E[0].findExtremities()['E'][0].y:\\n E.append(shore)\\n if extremityHash['W'][0].y < W[0].findExtremities()['W'][0].y:\\n W = [shore]\\n elif extremityHash['W'][0].y == W[0].findExtremities()['W'][0].y:\\n W.append(shore)\\n\\n # Now, lets flatten the list of cardinal extremities\\n flatList = [val for sublist in [N, S, E, W] for val in sublist]\\n counter = Counter(flatList)\\n\\n # In theory, the main pond shore should have the most extremities\\n probablyPond = counter.most_common(1)\\n\\n # Wow, what a piece of crap. I feel ashamed of the next 6 lines.\\n if probablyPond[0][0] < 4:\\n raise Exception(\\\"Largest Pond does not have 4 max points.\\\"\\n \\\" Something is horribly Wrong.\\\")\\n if len(probablyPond) != 1:\\n raise Exception(\\\"Equal number of extremities in pond?\\\"\\n \\\" How can that be?\\\")\\n\\n probablyPond = probablyPond[0][0]\\n\\n # Find any map edges and add them to the Plain Blob Object mapEdge.\\n self.mapEdge = self.findMapEdge()\\n\\n # Well, this probably isn't an island, so drop it from the list.\\n shoreList.remove(probablyPond)\\n\\n # Find any map edges for the island, and create Island Objects.\\n islands = list()\\n for island in shoreList:\\n islands.append(Island(island.points,\\n self.analyzeData,\\n self.elevation))\\n return islands\",\n \"def branching_factor(data, loc):\\n\\n return 20\",\n \"def test_specific_case(self):\\n fasta_file = os.path.normpath(get_fasta_file('T00759-tiny.fa'))\\n seed = 'AAAACCCA'\\n W = len(seed)\\n num_sites = 4\\n self.options.max_num_sites = num_sites\\n self.options.min_num_sites = num_sites\\n \\n #\\n # Load sequences and build index\\n #\\n algorithm = stempy.Algorithm(self.options)\\n algorithm._initialise(fasta_file)\\n data = algorithm.input_sequences.data\\n\\n model = algorithm.create_model_of_input(W)\\n model.bs.seed(seed, True)\\n model.set_lambda_for_sites(data.num_sequences)\\n\\n # look for best W-mers under model\\n best_w_mer_finder = stempy.create_best_w_mer_finder(data, model, num_sites)\\n best_w_mer_finder()\\n if len(best_w_mer_finder.best_w_mers) < num_sites:\\n if len(best_w_mer_finder.best_w_mers) != model.num_W_mers:\\n raise ValueError('Did not find enough W-mers')\\n \\n # We want to get these W-mers\\n # \\n # 2011-08-09 10:11:32,846 - INFO - Z=8.00e-02; pos= 313 +; AAAACCCA; AAAACCCA\\n # 2011-08-09 10:11:32,846 - INFO - Z=4.37e-02; pos= 668 -; TGAGTTTT; AAAACTCA\\n # 2011-08-09 10:11:32,846 - INFO - Z=1.37e-02; pos= 710 -; TGGTTTTC; GAAAACCA\\n # 2011-08-09 10:11:32,846 - INFO - Z=1.37e-02; pos= 681 -; TGGTTCTT; AAGAACCA\\n # \\n for wmer, (global_pos, rev_comp) in zip(best_w_mer_finder.best_w_mers, [(313, False), (668, True), (710, True), (681, True)]):\\n if wmer.global_pos != global_pos and wmer.Z < model.calculate_Z(global_pos, rev_comp):\\n raise ValueError('Got wrong W-mers')\",\n \"def _max_bits_used_in_function_in_round():\\n word_size = 16\\n bits_occupied = [word_size] * len(cost_functions)\\n for (pa, pb) in all_possible_pairs:\\n for i in range(len(cost_functions)):\\n max_sum_of_cost = num_pairings_in_round * \\\\\\n cost_functions[i](pa, pb)\\n while (max_sum_of_cost >= 2**bits_occupied[i]):\\n bits_occupied[i] *= 2\\n bits_occupied = [2*b for b in bits_occupied] # Paranoia\\n for b in bits_occupied:\\n assert(b % word_size == 0)\\n return max(bits_occupied)\",\n \"def lowest_cost_search(start, successors, is_goal, action_cost):\\r\\n Fail = []\\r\\n explored = set() # set of states we have visited\\r\\n frontier = [[start]] # ordered list of paths we have blazed\\r\\n while frontier:\\r\\n path = frontier.pop(0)\\r\\n state1 = final_state(path)\\r\\n if is_goal(state1):\\r\\n return path\\r\\n explored.add(state1)\\r\\n pcost = path_cost(path)\\r\\n for (state, action) in successors(state1).items():\\r\\n if state not in explored:\\r\\n total_cost = pcost + action_cost(action)\\r\\n path2 = path + [(action, total_cost), state]\\r\\n add_to_frontier(frontier, path2)\\r\\n return Fail\",\n \"def possible_rolls(D1,n):\\n possibilities = []\\n for D2 in range(1,7):\\n for D3 in range(1,7):\\n if D1+D2+D3 == n:\\n possibilities.append((D1,D2,D3))\\n return possibilities\",\n \"def correct_barcode_bitwise(query_seq, seq_possibilities,\\r\\n nt_to_bits=DEFAULT_GOLAY_NT_TO_BITS):\\r\\n if nt_to_bits is None:\\r\\n nt_to_bits = DEFAULT_NT_TO_BITS\\r\\n dists = []\\r\\n query_seq_bits = seq_to_bits(query_seq, nt_to_bits)\\r\\n for seq in seq_possibilities:\\r\\n possible_seq_bits = seq_to_bits(seq, nt_to_bits)\\r\\n dists.append(hamming_dist(query_seq_bits, possible_seq_bits))\\r\\n min_dist = min(dists)\\r\\n number_mins = dists.count(min_dist)\\r\\n if number_mins > 1:\\r\\n return None, min_dist\\r\\n else:\\r\\n best_hit = seq_possibilities[dists.index(min_dist)]\\r\\n return best_hit, min_dist\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n path_to_point = {}\\n cost_to_point = {}\\n\\n # Get the start node\\n start_node = problem.getStartState()\\n fringe_node = [start_node]\\n path_to_point[start_node] = []\\n cost_to_point[start_node] = problem.getCostOfActions(path_to_point[start_node])\\n\\n goal_found = False\\n\\n while(not goal_found):\\n #for i in range(100): \\n nodes_to_expand = set()\\n # get max value node in the fringe node\\n min_val = float(\\\"inf\\\")\\n for one_node in fringe_node:\\n # Compute the cost to reach a node\\n if cost_to_point[one_node] < min_val:\\n min_val = cost_to_point[one_node]\\n \\n for one_node in fringe_node:\\n # Compute the cost to reach a node\\n if cost_to_point[one_node] == min_val:\\n nodes_to_expand.add(one_node)\\n fringe_node.remove(one_node)\\n\\n # Expand the fringe node \\n for one_node in nodes_to_expand:\\n path_to_parent = path_to_point[one_node]\\n for nxt_node in problem.getSuccessors(one_node):\\n pos = nxt_node[0]\\n mv = nxt_node[1]\\n # check if point already present in path to point\\n prev_cost = float(\\\"inf\\\")\\n if pos in cost_to_point:\\n prev_cost = cost_to_point[pos]\\n new_path = path_to_parent + [mv]\\n if prev_cost > problem.getCostOfActions(new_path):\\n path_to_point[pos] = new_path\\n cost_to_point[pos] = problem.getCostOfActions(new_path)\\n fringe_node.append(pos)\\n\\n # Check if destination is reached in the fringe node\\n for one_node in fringe_node:\\n if problem.isGoalState(one_node):\\n final_node = one_node\\n goal_found = True\\n break\\n \\n #print(len(fringe_node))\\n print(final_node)\\n print(path_to_point[final_node])\\n return path_to_point[final_node] \\n\\n util.raiseNotDefined()\",\n \"def gene_finder(dna, threshold):\\n finder = []\\n twoStrands = find_all_ORFs_both_strands(dna) #this calls the function that finds the compliment of dna and finds all ORFs \\n print twoStrands \\n for k in range(len(twoStrands)): #go through the list \\\"twoStrands\\\"\\n if twoStrands[k]>threshold: #if the length of \\n print twoStrands[k]\\n print len(twoStrands[k])\\n finder.append(twoStrands[k])\\n return finder\",\n \"def test_possibilites(self):\\n self.assertEqual(self.RNA(\\\"\\\").possibilities(), 1)\\n self.assertEqual(self.RNA(\\\"ACGUgcaucagUCGuGCAU\\\").possibilities(), 1)\\n self.assertEqual(self.RNA(\\\"N\\\").possibilities(), 4)\\n self.assertEqual(self.RNA(\\\"R\\\").possibilities(), 2)\\n self.assertEqual(self.RNA(\\\"H\\\").possibilities(), 3)\\n self.assertEqual(self.RNA(\\\"nRh\\\").possibilities(), 24)\\n self.assertEqual(\\n self.RNA(\\\"AUGCnGUCAg-aurGauc--gauhcgauacgws\\\").possibilities(), 96\\n )\",\n \"def lowest_cost_search(start, successors, is_goal, action_cost):\\n explored = set()\\n frontier = [ [start] ]\\n if is_goal(start):\\n return frontier[0]\\n while frontier:\\n path = frontier.pop(0)\\n state1 = final_state(path)\\n if is_goal(state1):\\n return path\\n explored.add(state1)\\n pcost = path_cost(path)\\n for (state, action) in successors(state1).items():\\n if state not in explored:\\n total_cost = pcost +action_cost(action)\\n path2 = path + [(action, total_cost), state]\\n frontier.append(path2)\\n add_to_frontier(frontier, path2)\\n return Fail\",\n \"def test_solvation_with_additional_ions(self):\\n waters = np.random.randint(1000, 10000)\\n cations = ['LI', 'Na+', 'K+', 'RB', 'CS']\\n anions = ['F', 'Cl-', 'BR', 'IOD']\\n n_cations = np.random.randint(1, 10)\\n n_anions = np.random.randint(1, 10)\\n random_cation = random.choice(cations)\\n random_anion = random.choice(anions)\\n log.debug('Trying {} waters with additional ions...'.format(waters))\\n solvate(tleapfile='./cb6-but/tleap.in', pdbfile='cb6-but.pdb',\\n bufferwater=waters, neutralize=0,\\n addions=[random_cation, n_cations, random_anion, n_anions])\\n # These should come in the RESIDUE_LABEL region of the prmtop and be before all the water.\\n cation_number = sp.check_output([\\\"grep -A 99 RESIDUE_LABEL ./cb6-but/solvated.prmtop | \\\" +\\n \\\"grep -oh '{} ' | wc -w\\\".format(random_cation)],\\n shell=True)\\n anion_number = sp.check_output([\\\"grep -A 99 RESIDUE_LABEL ./cb6-but/solvated.prmtop | \\\" +\\n \\\"grep -oh '{} ' | wc -w\\\".format(random_anion)],\\n shell=True)\\n # Have to think about what to do here...\\n # log.debug('Expecting...')\\n # log.debug('cation = {}\\\\tn_cations={}'.format(random_cation, n_cations))\\n # log.debug('anion = {}\\\\t n_anions={}'.format(random_anion, n_anions))\\n # log.debug('Found...')\\n # log.debug(' n_cations={}'.format(cation_number))\\n # log.debug(' n_anions={}'.format(anion_number))\\n\\n self.assertTrue(int(cation_number) == n_cations and int(anion_number) == n_anions)\",\n \"def numberOfBoomerangsSlow(self, points):\\n\\n def is_boomerang(i, j, k):\\n dist_a = pow(j[0] - i[0], 2) + pow(j[1] - i[1], 2)\\n dist_b = pow(k[0] - i[0], 2) + pow(k[1] - i[1], 2)\\n return dist_a == dist_b\\n\\n total = 0\\n for i in points:\\n for j in points:\\n for k in points:\\n if i != j and j != k and is_boomerang(i, j, k):\\n total += 1\\n return total\",\n \"def canto_oposto_6(tab, jog):\\r\\n jog*=-1\\r\\n if obter_linha(tab,1)[0]==jog and eh_posicao_livre(tab,9):\\r\\n return 9\\r\\n if obter_linha(tab,1)[2]==jog and eh_posicao_livre(tab,7):\\r\\n return 7\\r\\n if obter_linha(tab,3)[0]==jog and eh_posicao_livre(tab,3):\\r\\n return 3\\r\\n if obter_linha(tab,3)[2]==jog and eh_posicao_livre(tab,1):\\r\\n return 1\",\n \"def _strength5(self, tournoi, best=5):\\n L = self.sorted_team_list()\\n s = 0\\n for i,e in enumerate(L):\\n if tournoi in e._positions:\\n s += 1\\n if s == best:\\n return i+1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6110882","0.60308844","0.5878015","0.5863746","0.5748723","0.5709508","0.56566536","0.56528664","0.5624614","0.5575636","0.5567551","0.55536634","0.5527198","0.55191416","0.5517331","0.5514932","0.5513137","0.5498134","0.5493011","0.54866076","0.5477608","0.5471907","0.54659927","0.5455559","0.5444958","0.5419081","0.5418015","0.54089713","0.53922737","0.5386362","0.53789437","0.5374194","0.53682625","0.5359618","0.53584284","0.53495204","0.5347124","0.5346038","0.5337049","0.5336462","0.5309436","0.5309209","0.5301492","0.53006816","0.5296525","0.52879256","0.528769","0.5286726","0.5285839","0.52803755","0.52803737","0.5280032","0.5274526","0.5271573","0.52688456","0.5262489","0.5252058","0.52460986","0.524433","0.5242488","0.52321696","0.5229745","0.52252674","0.5222987","0.52209073","0.52206063","0.52203536","0.52184343","0.5216354","0.52153623","0.52120864","0.5211499","0.52112097","0.5209768","0.52096236","0.52041936","0.52013737","0.52008986","0.5196617","0.5194507","0.5188689","0.51825035","0.5179124","0.51790565","0.51770186","0.5172212","0.51634425","0.5159106","0.51571864","0.51549774","0.51541835","0.5153991","0.5153843","0.514682","0.51420647","0.5141114","0.5136459","0.5129706","0.5126848","0.5126787"],"string":"[\n \"0.6110882\",\n \"0.60308844\",\n \"0.5878015\",\n \"0.5863746\",\n \"0.5748723\",\n \"0.5709508\",\n \"0.56566536\",\n \"0.56528664\",\n \"0.5624614\",\n \"0.5575636\",\n \"0.5567551\",\n \"0.55536634\",\n \"0.5527198\",\n \"0.55191416\",\n \"0.5517331\",\n \"0.5514932\",\n \"0.5513137\",\n \"0.5498134\",\n \"0.5493011\",\n \"0.54866076\",\n \"0.5477608\",\n \"0.5471907\",\n \"0.54659927\",\n \"0.5455559\",\n \"0.5444958\",\n \"0.5419081\",\n \"0.5418015\",\n \"0.54089713\",\n \"0.53922737\",\n \"0.5386362\",\n \"0.53789437\",\n \"0.5374194\",\n \"0.53682625\",\n \"0.5359618\",\n \"0.53584284\",\n \"0.53495204\",\n \"0.5347124\",\n \"0.5346038\",\n \"0.5337049\",\n \"0.5336462\",\n \"0.5309436\",\n \"0.5309209\",\n \"0.5301492\",\n \"0.53006816\",\n \"0.5296525\",\n \"0.52879256\",\n \"0.528769\",\n \"0.5286726\",\n \"0.5285839\",\n \"0.52803755\",\n \"0.52803737\",\n \"0.5280032\",\n \"0.5274526\",\n \"0.5271573\",\n \"0.52688456\",\n \"0.5262489\",\n \"0.5252058\",\n \"0.52460986\",\n \"0.524433\",\n \"0.5242488\",\n \"0.52321696\",\n \"0.5229745\",\n \"0.52252674\",\n \"0.5222987\",\n \"0.52209073\",\n \"0.52206063\",\n \"0.52203536\",\n \"0.52184343\",\n \"0.5216354\",\n \"0.52153623\",\n \"0.52120864\",\n \"0.5211499\",\n \"0.52112097\",\n \"0.5209768\",\n \"0.52096236\",\n \"0.52041936\",\n \"0.52013737\",\n \"0.52008986\",\n \"0.5196617\",\n \"0.5194507\",\n \"0.5188689\",\n \"0.51825035\",\n \"0.5179124\",\n \"0.51790565\",\n \"0.51770186\",\n \"0.5172212\",\n \"0.51634425\",\n \"0.5159106\",\n \"0.51571864\",\n \"0.51549774\",\n \"0.51541835\",\n \"0.5153991\",\n \"0.5153843\",\n \"0.514682\",\n \"0.51420647\",\n \"0.5141114\",\n \"0.5136459\",\n \"0.5129706\",\n \"0.5126848\",\n \"0.5126787\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5761488"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":3188,"cells":{"query":{"kind":"string","value":"Returns a Pythonnormalized String object from unicode."},"document":{"kind":"string","value":"def normalize_unicode_data(data):\n normalized_data = unicodedata.normalize('NFKD', data).encode('ascii', 'ignore')\n return normalized_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load(self, string):\r\n if isinstance(string, unicode):\r\n u = string\r\n else:\r\n u = unicode(string, self.encoding)\r\n return u","def as_unicode(string):\n return same_string_type_as(\"\", string)","def _as_unicode(s):\n if isinstance(s, str):\n return s\n # Assume it is a bytes string\n # Note ISO-8859-1 aka Latin-1 preserves first 256 chars\n return codecs.latin_1_decode(s)[0]","def u(s):\n if _IS_PYTHON_3 or type(s) == unicode:\n return s\n else:\n return codecs.unicode_escape_decode(s)[0]","def make_unicode(string):\n if sys.version < '3' and isinstance(string, str):\n return unicode(string.decode('utf-8'))\n\n return string","def force_unicode(s):\n return (s.decode('utf8')\n if isinstance(s, str)\n else unicode(s))","def asunicode(s):\n if isinstance(s, bytes):\n return s.decode('utf-8', 'replace')\n else:\n return s","def to_unicode(s, encoding=\"utf-8\"):\n if isinstance(s, six.text_type):\n return s\n elif isinstance(s, bytes):\n return s.decode(encoding)\n # TODO: warning? Exception?\n return s","def to_unicode(s):\n if isinstance(s, basestring):\n return force_unicode(s)\n return s","def force_unicode(s, encoding=encoding, errors='strict'):\n if isinstance(s, unicode):\n return s\n elif hasattr(s, '__unicode__'):\n return unicode(s)\n elif isinstance(s, str):\n return s.decode(encoding, errors)\n else:\n return str(s).decode(encoding, errors)","def FromUnicode(val):\n if sys.version_info[0] >= 3:\n return val\n return val if isinstance(val, str) else val.encode('utf-8')","def to_unicode(s):\n\n def brute_enc(s2):\n \"\"\"Trying to decode via simple brute forcing.\"\"\"\n encodings = (\"ascii\", \"utf8\", \"latin1\")\n for enc in encodings:\n try:\n return unicode(s2, enc)\n except UnicodeDecodeError:\n pass\n return None\n\n def chardet_enc(s2):\n \"\"\"Guess encoding via chardet.\"\"\"\n enc = chardet.detect(s2)[\"encoding\"]\n\n try:\n return unicode(s2, enc)\n except UnicodeDecodeError:\n pass\n return None\n\n # If already in unicode, skip.\n if isinstance(s, unicode):\n return s\n\n # First try to decode against a little set of common encodings.\n result = brute_enc(s)\n\n # Try via chardet.\n if not result:\n result = chardet_enc(s)\n\n # If not possible to convert the input string, try again with\n # a replace strategy.\n if not result:\n result = unicode(s, errors=\"replace\")\n\n return result","def to_unicode(string):\n assert isinstance(string, basestring)\n if sys.version_info[0] >= 3:\n if isinstance(string, bytes):\n return string.decode('utf-8')\n else:\n return string\n else:\n if isinstance(string, str):\n return string.decode('utf-8')\n else:\n return string","def to_unicode(self, _string):\n if not isinstance(_string, unicode):\n try:\n _string = unicode(_string)\n except:\n try:\n _string = _string.decode(\"utf-8\")\n except:\n _string = _string.decode(\"iso-8859-1\")\n return _string","def pystr(s):\n if six.PY2 and isinstance(s, six.text_type):\n return s.encode('ascii', 'ignore')\n elif six.PY3 and isinstance(s, six.binary_type):\n return s.decode('utf-8')\n else:\n return s","def string_unicode(text, encoding='utf-8'):\n try:\n if sys.version_info[0] >= 3:\n text = str(text)\n else:\n text = unicode(text, encoding) # pylint: disable=undefined-variable\n except: # pylint: disable=bare-except\n pass\n return text","def to_unicode(string):\n\n if isinstance(string, str):\n return string.decode('utf-8')\n else:\n return unicode(string)","def to_unicode(string):\n if not isinstance(string, unicode):\n for codec in CODECS:\r\n try:\r\n unic = unicode(string, codec)\r\n except UnicodeError:\r\n pass\r\n except TypeError:\r\n break\r\n else:\r\n return unic\r\n return string","def test_unicodeToString(self):\n self.assertNativeString(u\"Good day\", \"Good day\")","def smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\r\n # if isinstance(s, Promise):\r\n # # The input is the result of a gettext_lazy() call.\r\n # return s\r\n return force_unicode(s, encoding, strings_only, errors)","def cast_unicode(s, encoding='utf-8'):\n if isinstance(s, bytes) and not PY3:\n return s.decode(encoding, \"replace\")\n return s","def to_unicode (s, enc=ENCODING):\n\n if isinstance(s, basestring):\n if not isinstance(s, unicode):\n s = unicode(s, enc)\n return s","def u(obj):\n return obj if isinstance(obj, unicode) else unicode(obj) # noqa: F821 pylint: disable=undefined-variable","def ustr(obj):\n if IS_PY2:\n # If we are getting a string, then do an explicit decode\n # else, just call the unicode method of the object\n if type(obj) in [str, basestring]: # pragma: no cover # noqa\n return unicode(obj, DEFAULT_ENCODING) # pragma: no cover # noqa\n else:\n return unicode(obj) # pragma: no cover # noqa\n else:\n if type(obj) in [bytes]:\n return obj.decode(DEFAULT_ENCODING)\n else:\n return str(obj)","def utf8(unicode_str):\n if six.PY2 and isinstance(unicode_str, __unicode__):\n return unicode_str.encode('utf-8')\n\n return unicode_str","def smart_unicode(s, strings_only=False, errors='strict', encoding=None):\n\n return django_smart_unicode(\n s, encoding if encoding is not None else get_site_encoding(), strings_only, errors)","def try_unicode(string):\n if isinstance(string, str):\n return string.decode(\"utf-8\")\n else:\n return string","def smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\n return force_unicode(s, encoding, strings_only, errors)","def to_unicode(text, encoding='utf8', errors='strict'):\n if isinstance(text, str):\n return text\n return str(text, encoding, errors=errors)","def convert_to_unicode(text):\n if six.PY3:\n if isinstance(text, str):\n return text\n elif isinstance(text, bytes):\n return text.decode(\"utf-8\", \"ignore\")\n else:\n raise ValueError(\n \"Unsupported string type: %s\" % (type(text))\n ) # pragma: no cover","def Astr(string):\n\n return unicode(string, encoding='utf-8')","def str_to_unicode(encode_str, py_version=3):\n if (encode_str is None or encode_str == \"\" or encode_str == 'Null' or\n encode_str == 'null'):\n encode_str = \"\"\n elif ((py_version == 2 and isinstance(encode_str, str)) or (\n py_version == 3 and isinstance(encode_str, str))):\n pass\n else:\n code = get_encode(encode_str)\n encode_str = encode_str.decode(code, 'ignore')\n return encode_str","def unicode2utf8(s):\n return s.encode(encoding='utf-8', errors='ignore')","def _to_unicode(text):\n # both str and unicode inherit from basestring\n if not isinstance(text, basestring):\n tmpl = 'expected UTF-8 encoded string or unicode, got %s value %s'\n raise TypeError(tmpl % (type(text), text))\n # return unicode strings unchanged\n if isinstance(text, unicode):\n return text\n # otherwise assume UTF-8 encoding, which also works for ASCII\n return unicode(text, 'utf-8')","def to_native_str(s):\n if not isinstance(s, str):\n return s.decode('ascii', 'strict')\n return s","def to_unicode(text, charset=None):\n if not isinstance(text, str):\n if isinstance(text, Exception):\n # two possibilities for storing unicode strings in exception data:\n try:\n # custom __str__ method on the exception (e.g. PermissionError)\n return unicode(text)\n except UnicodeError:\n # unicode arguments given to the exception (e.g. parse_date)\n return ' '.join([to_unicode(arg) for arg in text.args])\n return unicode(text)\n if charset:\n return unicode(text, charset, 'replace')\n else:\n try:\n return unicode(text, 'utf-8')\n except UnicodeError:\n return unicode(text, locale.getpreferredencoding(), 'replace')","def to_unicode(text, charset=None):\n if not isinstance(text, str):\n if isinstance(text, Exception):\n # two possibilities for storing unicode strings in exception data:\n try:\n # custom __str__ method on the exception (e.g. PermissionError)\n return unicode(text)\n except UnicodeError:\n # unicode arguments given to the exception (e.g. parse_date)\n return ' '.join([to_unicode(arg) for arg in text.args])\n return unicode(text)\n if charset:\n return unicode(text, charset, 'replace')\n else:\n try:\n return unicode(text, 'utf-8')\n except UnicodeError:\n return unicode(text, locale.getpreferredencoding(), 'replace')","def _sanitize_string_for_python(self, s):\n s = repr(s)\n\n if s.startswith('u'):\n s = s[1:]\n\n return s","def stringToUnicode(x):\n if sys.version < '3':\n import codecs\n return codecs.unicode_escape_decode(x)[0]\n return x","def convert_to_unicode(text):\n if six.PY3:\n if isinstance(text, str):\n return text\n elif isinstance(text, bytes):\n return text.decode(\"utf-8\", \"ignore\")\n else:\n raise ValueError(\"Unsupported string type: %s\" % (type(text)))\n elif six.PY2:\n if isinstance(text, str):\n return text.decode(\"utf-8\", \"ignore\")\n elif isinstance(text, unicode):\n return text\n else:\n raise ValueError(\"Unsupported string type: %s\" % (type(text)))\n else:\n raise ValueError(\"Not running on Python2 or Python 3?\")","def convert_to_unicode(text):\n if six.PY3:\n if isinstance(text, str):\n return text\n elif isinstance(text, bytes):\n return text.decode(\"utf-8\", \"ignore\")\n else:\n raise ValueError(\"Unsupported string type: %s\" % (type(text)))\n elif six.PY2:\n if isinstance(text, str):\n return text.decode(\"utf-8\", \"ignore\")\n elif isinstance(text, unicode):\n return text\n else:\n raise ValueError(\"Unsupported string type: %s\" % (type(text)))\n else:\n raise ValueError(\"Not running on Python2 or Python 3?\")","def to_unicode(text, charset=None):\n if isinstance(text, str):\n try:\n return unicode(text, charset or 'utf-8')\n except UnicodeDecodeError:\n return unicode(text, 'latin1')\n elif isinstance(text, Exception):\n # two possibilities for storing unicode strings in exception data:\n try:\n # custom __str__ method on the exception (e.g. PermissionError)\n return unicode(text)\n except UnicodeError:\n # unicode arguments given to the exception (e.g. parse_date)\n return ' '.join([to_unicode(arg) for arg in text.args])\n return unicode(text)","def utf82unicode(s):\n return s.decode(encoding='utf-8', errors='ignore')","def native_(s, encoding='latin-1', errors='strict'):\n if isinstance(s, text_type):\n return s\n return str(s, encoding, errors)","def force_str(s):\n return (s.encode('utf8')\n if isinstance(s, unicode)\n else str(s))","def _string_convert(str):\n if isinstance(str, unicode):\n return str\n try:\n return str.decode(locale.getpreferredencoding(), 'strict')\n except UnicodeError:\n try:\n return str.decode(locale.getpreferredencoding(), 'replace')\n except UnicodeError:\n # unrepresentable string\n return u'????'","def str_to_unicode(text, encoding='utf-8'):\n if isinstance(text, str):\n return text.decode(encoding)\n elif isinstance(text, unicode):\n return text\n else:\n raise TypeError('str_to_unicode must receive a str or unicode object, got %s' % type(text).__name__)","def convert_to_unicode(text):\n if six.PY3:\n if isinstance(text, str):\n return text\n elif isinstance(text, bytes):\n return text.decode(\"utf-8\", \"ignore\")\n else:\n raise ValueError(\"Unsupported string type: %s, %s\" % (type(text), text))\n elif six.PY2:\n if isinstance(text, str):\n return text.decode(\"utf-8\", \"ignore\")\n elif isinstance(text, unicode):\n return text\n else:\n raise ValueError(\"Unsupported string type: %s\" % (type(text)))\n else:\n raise ValueError(\"Not running on Python2 or Python 3?\")","def to_unicode(text, encoding='utf8', errors='strict'):\r\n if isinstance(text, unicode):\r\n return text\r\n return unicode(text, encoding, errors=errors)","def translateString(s):\n\n if HAS_UTF8:\n return s\n\n return str(s.encode(), encoding = \"ASCII\", errors=\"backslashreplace\")","def safe_unicode(obj):\n try:\n return str(obj)\n except UnicodeDecodeError:\n return obj.decode(\"utf-8\")","def to_unicode(text, encoding='utf8', errors='strict'):\n if isinstance(text, unicode):\n return text\n return unicode(text, encoding, errors=errors)","def asunicode_win(s):\n if isinstance(s, bytes):\n return s.decode(locale.getpreferredencoding())\n else:\n return s","def TO_UNICODE(string):\n try:\n # wroks if string is unicode already\n return unicode(string, \"utf-8\")\n except:\n pass\n try:\n # works if string is iso8859-1\n return unicode(string, \"iso-8859-1\")\n except:\n pass\n # try simple coding\n return unicode(string)","def to_unicode(text, encoding='utf8', errors='strict'):\n if isinstance(text, unicode):\n return text\n else:\n return unicode(text, encoding=encoding, errors=errors)","def unicode_to_str(str1, logger=None, str_encode='system', py_version=3):\n if str1 is None or str1 == \"\" or str1 == 'Null' or str1 == 'null':\n str1 = \"\"\n elif ((py_version == 2 and isinstance(str1, str)) or (\n py_version == 3 and isinstance(str1, str))):\n try:\n if str_encode.lower() == 'system':\n str1 = str1.encode(sys.getfilesystemencoding(), 'ignore')\n elif str_encode.lower() == 'utf-8':\n str1 = str1.encode('utf-8', 'ignore')\n elif str_encode.lower() == 'gbk':\n str1 = str1.encode('gbk', 'ignore')\n else:\n str1 = str1.encode(str_encode, 'ignore')\n except UnicodeDecodeError as err_message:\n if logger:\n logger.info('[err]unicode_to_str:encode %s to %s failed',\n str1, str_encode)\n logger.info(str(err_message))\n elif ((py_version == 2 and isinstance(str1, str)) or (\n py_version == 3 and isinstance(str1, bytes))):\n pass\n else:\n if logger:\n logger.info('%s is not unicode ', str1)\n return str(str1)","def to_unicode(x):\n try: # This may never fail, but let's be safe\n encoding = locale.getpreferredencoding()\n except:\n encoding = 'utf-8'\n ret = x.decode(encoding, 'replace').encode('utf-8')\n return ret","def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\r\n if strings_only and isinstance(s, (types.NoneType, int)):\r\n return s\r\n if not isinstance(s, basestring,):\r\n if hasattr(s, '__unicode__'):\r\n s = unicode(s)\r\n else:\r\n s = unicode(str(s), encoding, errors)\r\n elif not isinstance(s, unicode):\r\n s = unicode(s, encoding, errors)\r\n return s","def unicodise(string, encoding = None, errors = \"replace\"):\n global preferred_encoding\n \n if not encoding:\n encoding = preferred_encoding\n\n if type(string) == unicode:\n return string\n try:\n return string.decode(encoding, errors)\n except UnicodeDecodeError:\n raise UnicodeDecodeError(\"Conversion to unicode failed: %r\" % string)","def _convert_string_to_unicode(string):\n result = string\n\n try:\n if string is not None and not isinstance(string, six.text_type):\n result = string.decode(\"utf-8\")\n except (TypeError, UnicodeDecodeError, AttributeError):\n # Sometimes the string actually is binary or StringIO object,\n # so if you can't decode it, just give up.\n pass\n\n return result","def as_unicode(obj):\n if sys.version_info.major < 3 and isinstance(obj, str):\n obj = obj.decode('utf-8')\n return unicode(obj)","def force_unicode(s, strings_only=False, errors='strict'):\n if sys.version_info[0] > 2:\n return django.utils.encoding.force_str(s, get_site_encoding(), strings_only, errors)\n else:\n return django.utils.encoding.force_unicode(s, get_site_encoding(), strings_only, errors)","def force_unicode(value):\n if IS_PY3:\n # Python 3.X\n if isinstance(value, bytes):\n value = value.decode(\"utf-8\", errors=\"replace\")\n elif not isinstance(value, str):\n value = str(value)\n else:\n # Python 2.X\n if isinstance(value, str):\n value = value.decode(\"utf-8\", \"replace\")\n elif not isinstance(value, basestring): # NOQA: F821\n value = unicode(value) # NOQA: F821\n\n return value","def ensure_unicode_string(value):\n if not isinstance(value, six.string_types):\n raise TypeError(u'Expected string value, got: {}'.format(value))\n return six.text_type(value)","def su(value):\n return safe_unicode(value, encoding=get_charset())","def normalize_unicode(str_data):\n try:\n normalized = unicodedata.normalize('NFKD', unicode(str_data)).encode('ascii', 'ignore')\n except UnicodeError:\n normalized = unicode(str_data, 'ascii', 'ignore')\n return normalized","def touni(x, enc='utf8', err='strict'):\r\n return x if isinstance(x, unicode) else unicode(str(x), enc, err)","def safe_unicode(e):\n try:\n return str(e)\n except UnicodeError:\n pass\n\n try:\n return repr(e)\n except UnicodeError:\n pass\n\n return u'Unrecoverably corrupt evalue'","def str_to_python(self, value):\r\n return unicode_safe(value)","def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\n if strings_only and isinstance(s, (types.NoneType, int, long, datetime.datetime, datetime.date, datetime.time, float)):\n return s\n try:\n if not isinstance(s, basestring,):\n if hasattr(s, '__unicode__'):\n s = unicode(s)\n else:\n try:\n s = unicode(str(s), encoding, errors)\n except UnicodeEncodeError:\n if not isinstance(s, Exception):\n raise\n # If we get to here, the caller has passed in an Exception\n # subclass populated with non-ASCII data without special\n # handling to display as a string. We need to handle this\n # without raising a further exception. We do an\n # approximation to what the Exception's standard str()\n # output should be.\n s = ' '.join([force_unicode(arg, encoding, strings_only,\n errors) for arg in s])\n elif not isinstance(s, unicode):\n # Note: We use .decode() here, instead of unicode(s, encoding,\n # errors), so that if s is a SafeString, it ends up being a\n # SafeUnicode at the end.\n s = s.decode(encoding, errors)\n except UnicodeDecodeError, e:\n raise CartolaUnicodeDecodeError(s, *e.args)\n return s","def display_unicode(self, string):\n if string is None:\n return ''\n return string.decode(\"utf16\", \"ignore\").encode(\"ascii\", 'backslashreplace')","def native_(s, encoding='latin-1', errors='strict'):\n if isinstance(s, text_type):\n return s.encode(encoding, errors)\n return str(s)","def safeunicode(obj, encoding='utf-8'):\n t = type(obj)\n if t is unicode:\n return obj\n elif t is str:\n return obj.decode(encoding, 'ignore')\n elif t in [int, float, bool]:\n return unicode(obj)\n elif hasattr(obj, '__unicode__') or isinstance(obj, unicode):\n try:\n return unicode(obj)\n except Exception as e:\n return u\"\"\n else:\n return str(obj).decode(encoding, 'ignore')","def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\r\n # Handle the common case first, saves 30-40% in performance when s\r\n # is an instance of unicode. This function gets called often in that\r\n # setting.\r\n if isinstance(s, unicode):\r\n return s\r\n if strings_only and is_protected_type(s):\r\n return s\r\n try:\r\n if not isinstance(s, basestring,):\r\n if hasattr(s, '__unicode__'):\r\n s = unicode(s)\r\n else:\r\n try:\r\n s = unicode(str(s), encoding, errors)\r\n except UnicodeEncodeError:\r\n if not isinstance(s, Exception):\r\n raise\r\n # If we get to here, the caller has passed in an Exception\r\n # subclass populated with non-ASCII data without special\r\n # handling to display as a string. We need to handle this\r\n # without raising a further exception. We do an\r\n # approximation to what the Exception's standard str()\r\n # output should be.\r\n s = u' '.join([force_unicode(arg, encoding, strings_only,\r\n errors) for arg in s])\r\n elif not isinstance(s, unicode):\r\n # Note: We use .decode() here, instead of unicode(s, encoding,\r\n # errors), so that if s is a SafeString, it ends up being a\r\n # SafeUnicode at the end.\r\n s = s.decode(encoding, errors)\r\n except UnicodeDecodeError, e:\r\n if not isinstance(s, Exception):\r\n raise DjangoUnicodeDecodeError(s, *e.args)\r\n else:\r\n # If we get to here, the caller has passed in an Exception\r\n # subclass populated with non-ASCII bytestring data without a\r\n # working unicode method. Try to handle this without raising a\r\n # further exception by individually forcing the exception args\r\n # to unicode.\r\n s = u' '.join([force_unicode(arg, encoding, strings_only,\r\n errors) for arg in s])\r\n return s","def as_unicode(value):\n assert value is None or isinstance(value,types.StringTypes)\n if isinstance(value,types.StringType):\n return value.decode('utf-8')\n else:\n return value","def _to_unicode(obj, encoding=\"UTF-8\"):\n if isinstance(obj, basestring):\n if not isinstance(obj, unicode):\n obj = unicode(obj, encoding)\n return obj","def to_unicode(text, encoding='utf-8', errors='strict'):\r\n if isinstance(text, bytes):\r\n return text.decode(encoding, errors=errors)\r\n return text","def safe_unicode(obj, *args):\n try:\n return unicode(obj, *args)\n except UnicodeDecodeError:\n # obj is byte string\n ascii_text = str(obj).encode('string_escape')\n return unicode(ascii_text)","def safe_unicode(obj, *args):\n try:\n return unicode(obj, *args)\n except UnicodeDecodeError:\n # obj is byte string\n ascii_text = str(obj).encode('string_escape')\n return unicode(ascii_text)","def safe_unicode(obj, *args):\n try:\n return unicode(obj, *args)\n except UnicodeDecodeError:\n # obj is byte string\n ascii_text = str(obj).encode('string_escape')\n return unicode(ascii_text)","def safe_unicode(obj, *args):\n try:\n return unicode(obj, *args)\n except UnicodeDecodeError:\n # obj is byte string\n ascii_text = str(obj).encode('string_escape')\n return unicode(ascii_text)","def safe_unicode(obj, *args):\n try:\n return unicode(obj, *args)\n except UnicodeDecodeError:\n # obj is byte string\n ascii_text = str(obj).encode('string_escape')\n return unicode(ascii_text)","def safe_unicode(obj, *args):\n try:\n return unicode(obj, *args)\n except UnicodeDecodeError:\n # obj is byte string\n ascii_text = str(obj).encode('string_escape')\n return unicode(ascii_text)","def _sanitize_string(self, string):\n # get the type of a unicode string\n unicode_type = type(Pyasciigraph._u('t'))\n input_type = type(string)\n if input_type is str:\n if sys.version < '3':\n info = unicode(string)\n else:\n info = string\n elif input_type is unicode_type:\n info = string\n elif input_type is int or input_type is float:\n if sys.version < '3':\n info = unicode(string)\n else:\n info = str(string)\n else:\n info = str(string)\n return info","def read_unicode_string(stream, size):\n\t\n\tvalue = u''\n\tif size > 0:\n\t\tdata = stream.read(size)\n\t\tdata = data.partition(chr(0))[0]\n\t\tvalue = unicode(data, 'utf_8')\n\treturn value","def utf8tounicode(arg):\n\n try:\n if isinstance(arg, unicode):\n return arg.decode('utf-8')\n except NameError:\n pass # Python 3\n return arg","def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\r\n if strings_only and is_protected_type(s):\r\n return s\r\n try:\r\n if not isinstance(s, basestring,):\r\n if hasattr(s, '__unicode__'):\r\n s = unicode(s)\r\n else:\r\n try:\r\n s = unicode(str(s), encoding, errors)\r\n except UnicodeEncodeError:\r\n if not isinstance(s, Exception):\r\n raise\r\n # If we get to here, the caller has passed in an Exception\r\n # subclass populated with non-ASCII data without special\r\n # handling to display as a string. We need to handle this\r\n # without raising a further exception. We do an\r\n # approximation to what the Exception's standard str()\r\n # output should be.\r\n s = ' '.join([force_unicode(arg, encoding, strings_only,\r\n errors) for arg in s])\r\n elif not isinstance(s, unicode):\r\n # Note: We use .decode() here, instead of unicode(s, encoding,\r\n # errors), so that if s is a SafeString, it ends up being a\r\n # SafeUnicode at the end.\r\n s = s.decode(encoding, errors)\r\n except UnicodeDecodeError, e:\r\n if not isinstance(s, Exception):\r\n raise TwitterTextUnicodeDecodeError(s, *e.args)\r\n else:\r\n # If we get to here, the caller has passed in an Exception\r\n # subclass populated with non-ASCII bytestring data without a\r\n # working unicode method. Try to handle this without raising a\r\n # further exception by individually forcing the exception args\r\n # to unicode.\r\n s = ' '.join([force_unicode(arg, encoding, strings_only,\r\n errors) for arg in s])\r\n return s","def qstringToString( text ):\n\treturn unicode( text.toUtf8(), \"utf-8\" )\n\t# try:\n\t\t# return str( text.toUtf8() )\n\t# except UnicodeDecodeError:\n\t\t# return unicode( text.toUtf8(), \"utf-8\" )","def decode_string(string):\n return unicode(string, 'utf-8')","def _unicodeify(self, value, encoding=\"utf8\"):\n if isinstance(value, str):\n return value\n return str(value, encoding)","def _to_str(s, encoding=\"utf8\", errors=\"ignore\"):\n if isinstance(s, bytes):\n return s.decode(encoding=encoding, errors=errors)\n return str(s)","def to_ascii(ustr):\n return ustr.encode('utf8')","def to_unicode(value):\r\n if isinstance(value, _TO_UNICODE_TYPES):\r\n return value\r\n if not isinstance(value, bytes_type):\r\n raise TypeError(\r\n \"Expected bytes, unicode, or None; got %r\" % type(value)\r\n )\r\n return value.decode(\"utf-8\")","def safeunicode(obj, encoding='utf-8'):\n t = type(obj)\n if t is unicode:\n return obj\n elif t is str:\n return obj.decode(encoding)\n elif t in [int, float, bool]:\n return unicode(obj)\n elif hasattr(obj, '__unicode__') or isinstance(obj, unicode):\n return unicode(obj)\n else:\n return str(obj).decode(encoding)","def toString(s):\n if type(s) == type(\"\"):\n return s\n else:\n return s.decode()","def _to_native_string(string, encoding='ascii'):\n if isinstance(string, str):\n out = string\n else:\n out = string.decode(encoding)\n\n return out","def to_unicode(data):\n if isinstance(data, bytes):\n return data.decode('utf-8')\n else:\n return data","def deunicodise(string, encoding = None, errors = \"replace\"):\n\n\tif not encoding:\n\t\tencoding = Config.Config().encoding\n\n\tif type(string) != unicode:\n\t\treturn str(string)\n\tdebug(\"DeUnicodising %r using %s\" % (string, encoding))\n\ttry:\n\t\treturn string.encode(encoding, errors)\n\texcept UnicodeEncodeError:\n\t\traise UnicodeEncodeError(\"Conversion from unicode failed: %r\" % string)","def remove_unicode(str):\n return unicodedata.normalize('NFKD', str).encode('ascii', 'ignore')","def _unicode_encode(self, s):\n if isinstance(s, unicode):\n return s.encode('utf-8')\n else:\n return s","def test_string_conversion():\n ob = ConversionTest()\n\n assert ob.StringField == \"spam\"\n assert ob.StringField == u\"spam\"\n\n ob.StringField = \"eggs\"\n assert ob.StringField == \"eggs\"\n assert ob.StringField == u\"eggs\"\n\n ob.StringField = u\"spam\"\n assert ob.StringField == \"spam\"\n assert ob.StringField == u\"spam\"\n\n ob.StringField = u'\\uffff\\uffff'\n assert ob.StringField == u'\\uffff\\uffff'\n\n ob.StringField = System.String(\"spam\")\n assert ob.StringField == \"spam\"\n assert ob.StringField == u\"spam\"\n\n ob.StringField = System.String(u'\\uffff\\uffff')\n assert ob.StringField == u'\\uffff\\uffff'\n\n ob.StringField = None\n assert ob.StringField is None\n\n with pytest.raises(TypeError):\n ConversionTest().StringField = 1\n\n world = UnicodeString()\n test_unicode_str = u\"안녕\"\n assert test_unicode_str == str(world.value)\n assert test_unicode_str == str(world.GetString())\n assert test_unicode_str == str(world)"],"string":"[\n \"def load(self, string):\\r\\n if isinstance(string, unicode):\\r\\n u = string\\r\\n else:\\r\\n u = unicode(string, self.encoding)\\r\\n return u\",\n \"def as_unicode(string):\\n return same_string_type_as(\\\"\\\", string)\",\n \"def _as_unicode(s):\\n if isinstance(s, str):\\n return s\\n # Assume it is a bytes string\\n # Note ISO-8859-1 aka Latin-1 preserves first 256 chars\\n return codecs.latin_1_decode(s)[0]\",\n \"def u(s):\\n if _IS_PYTHON_3 or type(s) == unicode:\\n return s\\n else:\\n return codecs.unicode_escape_decode(s)[0]\",\n \"def make_unicode(string):\\n if sys.version < '3' and isinstance(string, str):\\n return unicode(string.decode('utf-8'))\\n\\n return string\",\n \"def force_unicode(s):\\n return (s.decode('utf8')\\n if isinstance(s, str)\\n else unicode(s))\",\n \"def asunicode(s):\\n if isinstance(s, bytes):\\n return s.decode('utf-8', 'replace')\\n else:\\n return s\",\n \"def to_unicode(s, encoding=\\\"utf-8\\\"):\\n if isinstance(s, six.text_type):\\n return s\\n elif isinstance(s, bytes):\\n return s.decode(encoding)\\n # TODO: warning? Exception?\\n return s\",\n \"def to_unicode(s):\\n if isinstance(s, basestring):\\n return force_unicode(s)\\n return s\",\n \"def force_unicode(s, encoding=encoding, errors='strict'):\\n if isinstance(s, unicode):\\n return s\\n elif hasattr(s, '__unicode__'):\\n return unicode(s)\\n elif isinstance(s, str):\\n return s.decode(encoding, errors)\\n else:\\n return str(s).decode(encoding, errors)\",\n \"def FromUnicode(val):\\n if sys.version_info[0] >= 3:\\n return val\\n return val if isinstance(val, str) else val.encode('utf-8')\",\n \"def to_unicode(s):\\n\\n def brute_enc(s2):\\n \\\"\\\"\\\"Trying to decode via simple brute forcing.\\\"\\\"\\\"\\n encodings = (\\\"ascii\\\", \\\"utf8\\\", \\\"latin1\\\")\\n for enc in encodings:\\n try:\\n return unicode(s2, enc)\\n except UnicodeDecodeError:\\n pass\\n return None\\n\\n def chardet_enc(s2):\\n \\\"\\\"\\\"Guess encoding via chardet.\\\"\\\"\\\"\\n enc = chardet.detect(s2)[\\\"encoding\\\"]\\n\\n try:\\n return unicode(s2, enc)\\n except UnicodeDecodeError:\\n pass\\n return None\\n\\n # If already in unicode, skip.\\n if isinstance(s, unicode):\\n return s\\n\\n # First try to decode against a little set of common encodings.\\n result = brute_enc(s)\\n\\n # Try via chardet.\\n if not result:\\n result = chardet_enc(s)\\n\\n # If not possible to convert the input string, try again with\\n # a replace strategy.\\n if not result:\\n result = unicode(s, errors=\\\"replace\\\")\\n\\n return result\",\n \"def to_unicode(string):\\n assert isinstance(string, basestring)\\n if sys.version_info[0] >= 3:\\n if isinstance(string, bytes):\\n return string.decode('utf-8')\\n else:\\n return string\\n else:\\n if isinstance(string, str):\\n return string.decode('utf-8')\\n else:\\n return string\",\n \"def to_unicode(self, _string):\\n if not isinstance(_string, unicode):\\n try:\\n _string = unicode(_string)\\n except:\\n try:\\n _string = _string.decode(\\\"utf-8\\\")\\n except:\\n _string = _string.decode(\\\"iso-8859-1\\\")\\n return _string\",\n \"def pystr(s):\\n if six.PY2 and isinstance(s, six.text_type):\\n return s.encode('ascii', 'ignore')\\n elif six.PY3 and isinstance(s, six.binary_type):\\n return s.decode('utf-8')\\n else:\\n return s\",\n \"def string_unicode(text, encoding='utf-8'):\\n try:\\n if sys.version_info[0] >= 3:\\n text = str(text)\\n else:\\n text = unicode(text, encoding) # pylint: disable=undefined-variable\\n except: # pylint: disable=bare-except\\n pass\\n return text\",\n \"def to_unicode(string):\\n\\n if isinstance(string, str):\\n return string.decode('utf-8')\\n else:\\n return unicode(string)\",\n \"def to_unicode(string):\\n if not isinstance(string, unicode):\\n for codec in CODECS:\\r\\n try:\\r\\n unic = unicode(string, codec)\\r\\n except UnicodeError:\\r\\n pass\\r\\n except TypeError:\\r\\n break\\r\\n else:\\r\\n return unic\\r\\n return string\",\n \"def test_unicodeToString(self):\\n self.assertNativeString(u\\\"Good day\\\", \\\"Good day\\\")\",\n \"def smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\\r\\n # if isinstance(s, Promise):\\r\\n # # The input is the result of a gettext_lazy() call.\\r\\n # return s\\r\\n return force_unicode(s, encoding, strings_only, errors)\",\n \"def cast_unicode(s, encoding='utf-8'):\\n if isinstance(s, bytes) and not PY3:\\n return s.decode(encoding, \\\"replace\\\")\\n return s\",\n \"def to_unicode (s, enc=ENCODING):\\n\\n if isinstance(s, basestring):\\n if not isinstance(s, unicode):\\n s = unicode(s, enc)\\n return s\",\n \"def u(obj):\\n return obj if isinstance(obj, unicode) else unicode(obj) # noqa: F821 pylint: disable=undefined-variable\",\n \"def ustr(obj):\\n if IS_PY2:\\n # If we are getting a string, then do an explicit decode\\n # else, just call the unicode method of the object\\n if type(obj) in [str, basestring]: # pragma: no cover # noqa\\n return unicode(obj, DEFAULT_ENCODING) # pragma: no cover # noqa\\n else:\\n return unicode(obj) # pragma: no cover # noqa\\n else:\\n if type(obj) in [bytes]:\\n return obj.decode(DEFAULT_ENCODING)\\n else:\\n return str(obj)\",\n \"def utf8(unicode_str):\\n if six.PY2 and isinstance(unicode_str, __unicode__):\\n return unicode_str.encode('utf-8')\\n\\n return unicode_str\",\n \"def smart_unicode(s, strings_only=False, errors='strict', encoding=None):\\n\\n return django_smart_unicode(\\n s, encoding if encoding is not None else get_site_encoding(), strings_only, errors)\",\n \"def try_unicode(string):\\n if isinstance(string, str):\\n return string.decode(\\\"utf-8\\\")\\n else:\\n return string\",\n \"def smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\\n return force_unicode(s, encoding, strings_only, errors)\",\n \"def to_unicode(text, encoding='utf8', errors='strict'):\\n if isinstance(text, str):\\n return text\\n return str(text, encoding, errors=errors)\",\n \"def convert_to_unicode(text):\\n if six.PY3:\\n if isinstance(text, str):\\n return text\\n elif isinstance(text, bytes):\\n return text.decode(\\\"utf-8\\\", \\\"ignore\\\")\\n else:\\n raise ValueError(\\n \\\"Unsupported string type: %s\\\" % (type(text))\\n ) # pragma: no cover\",\n \"def Astr(string):\\n\\n return unicode(string, encoding='utf-8')\",\n \"def str_to_unicode(encode_str, py_version=3):\\n if (encode_str is None or encode_str == \\\"\\\" or encode_str == 'Null' or\\n encode_str == 'null'):\\n encode_str = \\\"\\\"\\n elif ((py_version == 2 and isinstance(encode_str, str)) or (\\n py_version == 3 and isinstance(encode_str, str))):\\n pass\\n else:\\n code = get_encode(encode_str)\\n encode_str = encode_str.decode(code, 'ignore')\\n return encode_str\",\n \"def unicode2utf8(s):\\n return s.encode(encoding='utf-8', errors='ignore')\",\n \"def _to_unicode(text):\\n # both str and unicode inherit from basestring\\n if not isinstance(text, basestring):\\n tmpl = 'expected UTF-8 encoded string or unicode, got %s value %s'\\n raise TypeError(tmpl % (type(text), text))\\n # return unicode strings unchanged\\n if isinstance(text, unicode):\\n return text\\n # otherwise assume UTF-8 encoding, which also works for ASCII\\n return unicode(text, 'utf-8')\",\n \"def to_native_str(s):\\n if not isinstance(s, str):\\n return s.decode('ascii', 'strict')\\n return s\",\n \"def to_unicode(text, charset=None):\\n if not isinstance(text, str):\\n if isinstance(text, Exception):\\n # two possibilities for storing unicode strings in exception data:\\n try:\\n # custom __str__ method on the exception (e.g. PermissionError)\\n return unicode(text)\\n except UnicodeError:\\n # unicode arguments given to the exception (e.g. parse_date)\\n return ' '.join([to_unicode(arg) for arg in text.args])\\n return unicode(text)\\n if charset:\\n return unicode(text, charset, 'replace')\\n else:\\n try:\\n return unicode(text, 'utf-8')\\n except UnicodeError:\\n return unicode(text, locale.getpreferredencoding(), 'replace')\",\n \"def to_unicode(text, charset=None):\\n if not isinstance(text, str):\\n if isinstance(text, Exception):\\n # two possibilities for storing unicode strings in exception data:\\n try:\\n # custom __str__ method on the exception (e.g. PermissionError)\\n return unicode(text)\\n except UnicodeError:\\n # unicode arguments given to the exception (e.g. parse_date)\\n return ' '.join([to_unicode(arg) for arg in text.args])\\n return unicode(text)\\n if charset:\\n return unicode(text, charset, 'replace')\\n else:\\n try:\\n return unicode(text, 'utf-8')\\n except UnicodeError:\\n return unicode(text, locale.getpreferredencoding(), 'replace')\",\n \"def _sanitize_string_for_python(self, s):\\n s = repr(s)\\n\\n if s.startswith('u'):\\n s = s[1:]\\n\\n return s\",\n \"def stringToUnicode(x):\\n if sys.version < '3':\\n import codecs\\n return codecs.unicode_escape_decode(x)[0]\\n return x\",\n \"def convert_to_unicode(text):\\n if six.PY3:\\n if isinstance(text, str):\\n return text\\n elif isinstance(text, bytes):\\n return text.decode(\\\"utf-8\\\", \\\"ignore\\\")\\n else:\\n raise ValueError(\\\"Unsupported string type: %s\\\" % (type(text)))\\n elif six.PY2:\\n if isinstance(text, str):\\n return text.decode(\\\"utf-8\\\", \\\"ignore\\\")\\n elif isinstance(text, unicode):\\n return text\\n else:\\n raise ValueError(\\\"Unsupported string type: %s\\\" % (type(text)))\\n else:\\n raise ValueError(\\\"Not running on Python2 or Python 3?\\\")\",\n \"def convert_to_unicode(text):\\n if six.PY3:\\n if isinstance(text, str):\\n return text\\n elif isinstance(text, bytes):\\n return text.decode(\\\"utf-8\\\", \\\"ignore\\\")\\n else:\\n raise ValueError(\\\"Unsupported string type: %s\\\" % (type(text)))\\n elif six.PY2:\\n if isinstance(text, str):\\n return text.decode(\\\"utf-8\\\", \\\"ignore\\\")\\n elif isinstance(text, unicode):\\n return text\\n else:\\n raise ValueError(\\\"Unsupported string type: %s\\\" % (type(text)))\\n else:\\n raise ValueError(\\\"Not running on Python2 or Python 3?\\\")\",\n \"def to_unicode(text, charset=None):\\n if isinstance(text, str):\\n try:\\n return unicode(text, charset or 'utf-8')\\n except UnicodeDecodeError:\\n return unicode(text, 'latin1')\\n elif isinstance(text, Exception):\\n # two possibilities for storing unicode strings in exception data:\\n try:\\n # custom __str__ method on the exception (e.g. PermissionError)\\n return unicode(text)\\n except UnicodeError:\\n # unicode arguments given to the exception (e.g. parse_date)\\n return ' '.join([to_unicode(arg) for arg in text.args])\\n return unicode(text)\",\n \"def utf82unicode(s):\\n return s.decode(encoding='utf-8', errors='ignore')\",\n \"def native_(s, encoding='latin-1', errors='strict'):\\n if isinstance(s, text_type):\\n return s\\n return str(s, encoding, errors)\",\n \"def force_str(s):\\n return (s.encode('utf8')\\n if isinstance(s, unicode)\\n else str(s))\",\n \"def _string_convert(str):\\n if isinstance(str, unicode):\\n return str\\n try:\\n return str.decode(locale.getpreferredencoding(), 'strict')\\n except UnicodeError:\\n try:\\n return str.decode(locale.getpreferredencoding(), 'replace')\\n except UnicodeError:\\n # unrepresentable string\\n return u'????'\",\n \"def str_to_unicode(text, encoding='utf-8'):\\n if isinstance(text, str):\\n return text.decode(encoding)\\n elif isinstance(text, unicode):\\n return text\\n else:\\n raise TypeError('str_to_unicode must receive a str or unicode object, got %s' % type(text).__name__)\",\n \"def convert_to_unicode(text):\\n if six.PY3:\\n if isinstance(text, str):\\n return text\\n elif isinstance(text, bytes):\\n return text.decode(\\\"utf-8\\\", \\\"ignore\\\")\\n else:\\n raise ValueError(\\\"Unsupported string type: %s, %s\\\" % (type(text), text))\\n elif six.PY2:\\n if isinstance(text, str):\\n return text.decode(\\\"utf-8\\\", \\\"ignore\\\")\\n elif isinstance(text, unicode):\\n return text\\n else:\\n raise ValueError(\\\"Unsupported string type: %s\\\" % (type(text)))\\n else:\\n raise ValueError(\\\"Not running on Python2 or Python 3?\\\")\",\n \"def to_unicode(text, encoding='utf8', errors='strict'):\\r\\n if isinstance(text, unicode):\\r\\n return text\\r\\n return unicode(text, encoding, errors=errors)\",\n \"def translateString(s):\\n\\n if HAS_UTF8:\\n return s\\n\\n return str(s.encode(), encoding = \\\"ASCII\\\", errors=\\\"backslashreplace\\\")\",\n \"def safe_unicode(obj):\\n try:\\n return str(obj)\\n except UnicodeDecodeError:\\n return obj.decode(\\\"utf-8\\\")\",\n \"def to_unicode(text, encoding='utf8', errors='strict'):\\n if isinstance(text, unicode):\\n return text\\n return unicode(text, encoding, errors=errors)\",\n \"def asunicode_win(s):\\n if isinstance(s, bytes):\\n return s.decode(locale.getpreferredencoding())\\n else:\\n return s\",\n \"def TO_UNICODE(string):\\n try:\\n # wroks if string is unicode already\\n return unicode(string, \\\"utf-8\\\")\\n except:\\n pass\\n try:\\n # works if string is iso8859-1\\n return unicode(string, \\\"iso-8859-1\\\")\\n except:\\n pass\\n # try simple coding\\n return unicode(string)\",\n \"def to_unicode(text, encoding='utf8', errors='strict'):\\n if isinstance(text, unicode):\\n return text\\n else:\\n return unicode(text, encoding=encoding, errors=errors)\",\n \"def unicode_to_str(str1, logger=None, str_encode='system', py_version=3):\\n if str1 is None or str1 == \\\"\\\" or str1 == 'Null' or str1 == 'null':\\n str1 = \\\"\\\"\\n elif ((py_version == 2 and isinstance(str1, str)) or (\\n py_version == 3 and isinstance(str1, str))):\\n try:\\n if str_encode.lower() == 'system':\\n str1 = str1.encode(sys.getfilesystemencoding(), 'ignore')\\n elif str_encode.lower() == 'utf-8':\\n str1 = str1.encode('utf-8', 'ignore')\\n elif str_encode.lower() == 'gbk':\\n str1 = str1.encode('gbk', 'ignore')\\n else:\\n str1 = str1.encode(str_encode, 'ignore')\\n except UnicodeDecodeError as err_message:\\n if logger:\\n logger.info('[err]unicode_to_str:encode %s to %s failed',\\n str1, str_encode)\\n logger.info(str(err_message))\\n elif ((py_version == 2 and isinstance(str1, str)) or (\\n py_version == 3 and isinstance(str1, bytes))):\\n pass\\n else:\\n if logger:\\n logger.info('%s is not unicode ', str1)\\n return str(str1)\",\n \"def to_unicode(x):\\n try: # This may never fail, but let's be safe\\n encoding = locale.getpreferredencoding()\\n except:\\n encoding = 'utf-8'\\n ret = x.decode(encoding, 'replace').encode('utf-8')\\n return ret\",\n \"def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\\r\\n if strings_only and isinstance(s, (types.NoneType, int)):\\r\\n return s\\r\\n if not isinstance(s, basestring,):\\r\\n if hasattr(s, '__unicode__'):\\r\\n s = unicode(s)\\r\\n else:\\r\\n s = unicode(str(s), encoding, errors)\\r\\n elif not isinstance(s, unicode):\\r\\n s = unicode(s, encoding, errors)\\r\\n return s\",\n \"def unicodise(string, encoding = None, errors = \\\"replace\\\"):\\n global preferred_encoding\\n \\n if not encoding:\\n encoding = preferred_encoding\\n\\n if type(string) == unicode:\\n return string\\n try:\\n return string.decode(encoding, errors)\\n except UnicodeDecodeError:\\n raise UnicodeDecodeError(\\\"Conversion to unicode failed: %r\\\" % string)\",\n \"def _convert_string_to_unicode(string):\\n result = string\\n\\n try:\\n if string is not None and not isinstance(string, six.text_type):\\n result = string.decode(\\\"utf-8\\\")\\n except (TypeError, UnicodeDecodeError, AttributeError):\\n # Sometimes the string actually is binary or StringIO object,\\n # so if you can't decode it, just give up.\\n pass\\n\\n return result\",\n \"def as_unicode(obj):\\n if sys.version_info.major < 3 and isinstance(obj, str):\\n obj = obj.decode('utf-8')\\n return unicode(obj)\",\n \"def force_unicode(s, strings_only=False, errors='strict'):\\n if sys.version_info[0] > 2:\\n return django.utils.encoding.force_str(s, get_site_encoding(), strings_only, errors)\\n else:\\n return django.utils.encoding.force_unicode(s, get_site_encoding(), strings_only, errors)\",\n \"def force_unicode(value):\\n if IS_PY3:\\n # Python 3.X\\n if isinstance(value, bytes):\\n value = value.decode(\\\"utf-8\\\", errors=\\\"replace\\\")\\n elif not isinstance(value, str):\\n value = str(value)\\n else:\\n # Python 2.X\\n if isinstance(value, str):\\n value = value.decode(\\\"utf-8\\\", \\\"replace\\\")\\n elif not isinstance(value, basestring): # NOQA: F821\\n value = unicode(value) # NOQA: F821\\n\\n return value\",\n \"def ensure_unicode_string(value):\\n if not isinstance(value, six.string_types):\\n raise TypeError(u'Expected string value, got: {}'.format(value))\\n return six.text_type(value)\",\n \"def su(value):\\n return safe_unicode(value, encoding=get_charset())\",\n \"def normalize_unicode(str_data):\\n try:\\n normalized = unicodedata.normalize('NFKD', unicode(str_data)).encode('ascii', 'ignore')\\n except UnicodeError:\\n normalized = unicode(str_data, 'ascii', 'ignore')\\n return normalized\",\n \"def touni(x, enc='utf8', err='strict'):\\r\\n return x if isinstance(x, unicode) else unicode(str(x), enc, err)\",\n \"def safe_unicode(e):\\n try:\\n return str(e)\\n except UnicodeError:\\n pass\\n\\n try:\\n return repr(e)\\n except UnicodeError:\\n pass\\n\\n return u'Unrecoverably corrupt evalue'\",\n \"def str_to_python(self, value):\\r\\n return unicode_safe(value)\",\n \"def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\\n if strings_only and isinstance(s, (types.NoneType, int, long, datetime.datetime, datetime.date, datetime.time, float)):\\n return s\\n try:\\n if not isinstance(s, basestring,):\\n if hasattr(s, '__unicode__'):\\n s = unicode(s)\\n else:\\n try:\\n s = unicode(str(s), encoding, errors)\\n except UnicodeEncodeError:\\n if not isinstance(s, Exception):\\n raise\\n # If we get to here, the caller has passed in an Exception\\n # subclass populated with non-ASCII data without special\\n # handling to display as a string. We need to handle this\\n # without raising a further exception. We do an\\n # approximation to what the Exception's standard str()\\n # output should be.\\n s = ' '.join([force_unicode(arg, encoding, strings_only,\\n errors) for arg in s])\\n elif not isinstance(s, unicode):\\n # Note: We use .decode() here, instead of unicode(s, encoding,\\n # errors), so that if s is a SafeString, it ends up being a\\n # SafeUnicode at the end.\\n s = s.decode(encoding, errors)\\n except UnicodeDecodeError, e:\\n raise CartolaUnicodeDecodeError(s, *e.args)\\n return s\",\n \"def display_unicode(self, string):\\n if string is None:\\n return ''\\n return string.decode(\\\"utf16\\\", \\\"ignore\\\").encode(\\\"ascii\\\", 'backslashreplace')\",\n \"def native_(s, encoding='latin-1', errors='strict'):\\n if isinstance(s, text_type):\\n return s.encode(encoding, errors)\\n return str(s)\",\n \"def safeunicode(obj, encoding='utf-8'):\\n t = type(obj)\\n if t is unicode:\\n return obj\\n elif t is str:\\n return obj.decode(encoding, 'ignore')\\n elif t in [int, float, bool]:\\n return unicode(obj)\\n elif hasattr(obj, '__unicode__') or isinstance(obj, unicode):\\n try:\\n return unicode(obj)\\n except Exception as e:\\n return u\\\"\\\"\\n else:\\n return str(obj).decode(encoding, 'ignore')\",\n \"def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\\r\\n # Handle the common case first, saves 30-40% in performance when s\\r\\n # is an instance of unicode. This function gets called often in that\\r\\n # setting.\\r\\n if isinstance(s, unicode):\\r\\n return s\\r\\n if strings_only and is_protected_type(s):\\r\\n return s\\r\\n try:\\r\\n if not isinstance(s, basestring,):\\r\\n if hasattr(s, '__unicode__'):\\r\\n s = unicode(s)\\r\\n else:\\r\\n try:\\r\\n s = unicode(str(s), encoding, errors)\\r\\n except UnicodeEncodeError:\\r\\n if not isinstance(s, Exception):\\r\\n raise\\r\\n # If we get to here, the caller has passed in an Exception\\r\\n # subclass populated with non-ASCII data without special\\r\\n # handling to display as a string. We need to handle this\\r\\n # without raising a further exception. We do an\\r\\n # approximation to what the Exception's standard str()\\r\\n # output should be.\\r\\n s = u' '.join([force_unicode(arg, encoding, strings_only,\\r\\n errors) for arg in s])\\r\\n elif not isinstance(s, unicode):\\r\\n # Note: We use .decode() here, instead of unicode(s, encoding,\\r\\n # errors), so that if s is a SafeString, it ends up being a\\r\\n # SafeUnicode at the end.\\r\\n s = s.decode(encoding, errors)\\r\\n except UnicodeDecodeError, e:\\r\\n if not isinstance(s, Exception):\\r\\n raise DjangoUnicodeDecodeError(s, *e.args)\\r\\n else:\\r\\n # If we get to here, the caller has passed in an Exception\\r\\n # subclass populated with non-ASCII bytestring data without a\\r\\n # working unicode method. Try to handle this without raising a\\r\\n # further exception by individually forcing the exception args\\r\\n # to unicode.\\r\\n s = u' '.join([force_unicode(arg, encoding, strings_only,\\r\\n errors) for arg in s])\\r\\n return s\",\n \"def as_unicode(value):\\n assert value is None or isinstance(value,types.StringTypes)\\n if isinstance(value,types.StringType):\\n return value.decode('utf-8')\\n else:\\n return value\",\n \"def _to_unicode(obj, encoding=\\\"UTF-8\\\"):\\n if isinstance(obj, basestring):\\n if not isinstance(obj, unicode):\\n obj = unicode(obj, encoding)\\n return obj\",\n \"def to_unicode(text, encoding='utf-8', errors='strict'):\\r\\n if isinstance(text, bytes):\\r\\n return text.decode(encoding, errors=errors)\\r\\n return text\",\n \"def safe_unicode(obj, *args):\\n try:\\n return unicode(obj, *args)\\n except UnicodeDecodeError:\\n # obj is byte string\\n ascii_text = str(obj).encode('string_escape')\\n return unicode(ascii_text)\",\n \"def safe_unicode(obj, *args):\\n try:\\n return unicode(obj, *args)\\n except UnicodeDecodeError:\\n # obj is byte string\\n ascii_text = str(obj).encode('string_escape')\\n return unicode(ascii_text)\",\n \"def safe_unicode(obj, *args):\\n try:\\n return unicode(obj, *args)\\n except UnicodeDecodeError:\\n # obj is byte string\\n ascii_text = str(obj).encode('string_escape')\\n return unicode(ascii_text)\",\n \"def safe_unicode(obj, *args):\\n try:\\n return unicode(obj, *args)\\n except UnicodeDecodeError:\\n # obj is byte string\\n ascii_text = str(obj).encode('string_escape')\\n return unicode(ascii_text)\",\n \"def safe_unicode(obj, *args):\\n try:\\n return unicode(obj, *args)\\n except UnicodeDecodeError:\\n # obj is byte string\\n ascii_text = str(obj).encode('string_escape')\\n return unicode(ascii_text)\",\n \"def safe_unicode(obj, *args):\\n try:\\n return unicode(obj, *args)\\n except UnicodeDecodeError:\\n # obj is byte string\\n ascii_text = str(obj).encode('string_escape')\\n return unicode(ascii_text)\",\n \"def _sanitize_string(self, string):\\n # get the type of a unicode string\\n unicode_type = type(Pyasciigraph._u('t'))\\n input_type = type(string)\\n if input_type is str:\\n if sys.version < '3':\\n info = unicode(string)\\n else:\\n info = string\\n elif input_type is unicode_type:\\n info = string\\n elif input_type is int or input_type is float:\\n if sys.version < '3':\\n info = unicode(string)\\n else:\\n info = str(string)\\n else:\\n info = str(string)\\n return info\",\n \"def read_unicode_string(stream, size):\\n\\t\\n\\tvalue = u''\\n\\tif size > 0:\\n\\t\\tdata = stream.read(size)\\n\\t\\tdata = data.partition(chr(0))[0]\\n\\t\\tvalue = unicode(data, 'utf_8')\\n\\treturn value\",\n \"def utf8tounicode(arg):\\n\\n try:\\n if isinstance(arg, unicode):\\n return arg.decode('utf-8')\\n except NameError:\\n pass # Python 3\\n return arg\",\n \"def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):\\r\\n if strings_only and is_protected_type(s):\\r\\n return s\\r\\n try:\\r\\n if not isinstance(s, basestring,):\\r\\n if hasattr(s, '__unicode__'):\\r\\n s = unicode(s)\\r\\n else:\\r\\n try:\\r\\n s = unicode(str(s), encoding, errors)\\r\\n except UnicodeEncodeError:\\r\\n if not isinstance(s, Exception):\\r\\n raise\\r\\n # If we get to here, the caller has passed in an Exception\\r\\n # subclass populated with non-ASCII data without special\\r\\n # handling to display as a string. We need to handle this\\r\\n # without raising a further exception. We do an\\r\\n # approximation to what the Exception's standard str()\\r\\n # output should be.\\r\\n s = ' '.join([force_unicode(arg, encoding, strings_only,\\r\\n errors) for arg in s])\\r\\n elif not isinstance(s, unicode):\\r\\n # Note: We use .decode() here, instead of unicode(s, encoding,\\r\\n # errors), so that if s is a SafeString, it ends up being a\\r\\n # SafeUnicode at the end.\\r\\n s = s.decode(encoding, errors)\\r\\n except UnicodeDecodeError, e:\\r\\n if not isinstance(s, Exception):\\r\\n raise TwitterTextUnicodeDecodeError(s, *e.args)\\r\\n else:\\r\\n # If we get to here, the caller has passed in an Exception\\r\\n # subclass populated with non-ASCII bytestring data without a\\r\\n # working unicode method. Try to handle this without raising a\\r\\n # further exception by individually forcing the exception args\\r\\n # to unicode.\\r\\n s = ' '.join([force_unicode(arg, encoding, strings_only,\\r\\n errors) for arg in s])\\r\\n return s\",\n \"def qstringToString( text ):\\n\\treturn unicode( text.toUtf8(), \\\"utf-8\\\" )\\n\\t# try:\\n\\t\\t# return str( text.toUtf8() )\\n\\t# except UnicodeDecodeError:\\n\\t\\t# return unicode( text.toUtf8(), \\\"utf-8\\\" )\",\n \"def decode_string(string):\\n return unicode(string, 'utf-8')\",\n \"def _unicodeify(self, value, encoding=\\\"utf8\\\"):\\n if isinstance(value, str):\\n return value\\n return str(value, encoding)\",\n \"def _to_str(s, encoding=\\\"utf8\\\", errors=\\\"ignore\\\"):\\n if isinstance(s, bytes):\\n return s.decode(encoding=encoding, errors=errors)\\n return str(s)\",\n \"def to_ascii(ustr):\\n return ustr.encode('utf8')\",\n \"def to_unicode(value):\\r\\n if isinstance(value, _TO_UNICODE_TYPES):\\r\\n return value\\r\\n if not isinstance(value, bytes_type):\\r\\n raise TypeError(\\r\\n \\\"Expected bytes, unicode, or None; got %r\\\" % type(value)\\r\\n )\\r\\n return value.decode(\\\"utf-8\\\")\",\n \"def safeunicode(obj, encoding='utf-8'):\\n t = type(obj)\\n if t is unicode:\\n return obj\\n elif t is str:\\n return obj.decode(encoding)\\n elif t in [int, float, bool]:\\n return unicode(obj)\\n elif hasattr(obj, '__unicode__') or isinstance(obj, unicode):\\n return unicode(obj)\\n else:\\n return str(obj).decode(encoding)\",\n \"def toString(s):\\n if type(s) == type(\\\"\\\"):\\n return s\\n else:\\n return s.decode()\",\n \"def _to_native_string(string, encoding='ascii'):\\n if isinstance(string, str):\\n out = string\\n else:\\n out = string.decode(encoding)\\n\\n return out\",\n \"def to_unicode(data):\\n if isinstance(data, bytes):\\n return data.decode('utf-8')\\n else:\\n return data\",\n \"def deunicodise(string, encoding = None, errors = \\\"replace\\\"):\\n\\n\\tif not encoding:\\n\\t\\tencoding = Config.Config().encoding\\n\\n\\tif type(string) != unicode:\\n\\t\\treturn str(string)\\n\\tdebug(\\\"DeUnicodising %r using %s\\\" % (string, encoding))\\n\\ttry:\\n\\t\\treturn string.encode(encoding, errors)\\n\\texcept UnicodeEncodeError:\\n\\t\\traise UnicodeEncodeError(\\\"Conversion from unicode failed: %r\\\" % string)\",\n \"def remove_unicode(str):\\n return unicodedata.normalize('NFKD', str).encode('ascii', 'ignore')\",\n \"def _unicode_encode(self, s):\\n if isinstance(s, unicode):\\n return s.encode('utf-8')\\n else:\\n return s\",\n \"def test_string_conversion():\\n ob = ConversionTest()\\n\\n assert ob.StringField == \\\"spam\\\"\\n assert ob.StringField == u\\\"spam\\\"\\n\\n ob.StringField = \\\"eggs\\\"\\n assert ob.StringField == \\\"eggs\\\"\\n assert ob.StringField == u\\\"eggs\\\"\\n\\n ob.StringField = u\\\"spam\\\"\\n assert ob.StringField == \\\"spam\\\"\\n assert ob.StringField == u\\\"spam\\\"\\n\\n ob.StringField = u'\\\\uffff\\\\uffff'\\n assert ob.StringField == u'\\\\uffff\\\\uffff'\\n\\n ob.StringField = System.String(\\\"spam\\\")\\n assert ob.StringField == \\\"spam\\\"\\n assert ob.StringField == u\\\"spam\\\"\\n\\n ob.StringField = System.String(u'\\\\uffff\\\\uffff')\\n assert ob.StringField == u'\\\\uffff\\\\uffff'\\n\\n ob.StringField = None\\n assert ob.StringField is None\\n\\n with pytest.raises(TypeError):\\n ConversionTest().StringField = 1\\n\\n world = UnicodeString()\\n test_unicode_str = u\\\"안녕\\\"\\n assert test_unicode_str == str(world.value)\\n assert test_unicode_str == str(world.GetString())\\n assert test_unicode_str == str(world)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7233125","0.71349865","0.7019128","0.70103765","0.6991322","0.6916738","0.6904967","0.68421304","0.6790128","0.67792904","0.671786","0.6711641","0.67108285","0.66316116","0.6597703","0.6570314","0.6567923","0.65449303","0.6489974","0.645341","0.64313215","0.64283127","0.64277136","0.6379462","0.63575","0.6354504","0.63370895","0.6333765","0.6331147","0.63203037","0.6301418","0.6294504","0.6293388","0.629289","0.6289198","0.62811357","0.62811357","0.6238869","0.6232138","0.6221927","0.6221927","0.61935693","0.61902726","0.6185412","0.61813194","0.6169025","0.6160391","0.6156622","0.6137323","0.6126727","0.6113291","0.6108429","0.61025006","0.6096889","0.6085063","0.6084808","0.60712713","0.60656816","0.6059236","0.605465","0.604833","0.6042607","0.6016483","0.59988004","0.59960717","0.5995823","0.5976453","0.5976264","0.5967838","0.5962056","0.59535813","0.5945487","0.5924718","0.59099644","0.59070736","0.58992547","0.5895074","0.5848422","0.5848422","0.5848422","0.5848422","0.5848422","0.5848422","0.5841469","0.58357006","0.58246833","0.5811975","0.58106863","0.5807386","0.57971436","0.57926047","0.57898843","0.5784179","0.57753944","0.5771162","0.57689476","0.5757701","0.57539934","0.5752122","0.5751116","0.5742965"],"string":"[\n \"0.7233125\",\n \"0.71349865\",\n \"0.7019128\",\n \"0.70103765\",\n \"0.6991322\",\n \"0.6916738\",\n \"0.6904967\",\n \"0.68421304\",\n \"0.6790128\",\n \"0.67792904\",\n \"0.671786\",\n \"0.6711641\",\n \"0.67108285\",\n \"0.66316116\",\n \"0.6597703\",\n \"0.6570314\",\n \"0.6567923\",\n \"0.65449303\",\n \"0.6489974\",\n \"0.645341\",\n \"0.64313215\",\n \"0.64283127\",\n \"0.64277136\",\n \"0.6379462\",\n \"0.63575\",\n \"0.6354504\",\n \"0.63370895\",\n \"0.6333765\",\n \"0.6331147\",\n \"0.63203037\",\n \"0.6301418\",\n \"0.6294504\",\n \"0.6293388\",\n \"0.629289\",\n \"0.6289198\",\n \"0.62811357\",\n \"0.62811357\",\n \"0.6238869\",\n \"0.6232138\",\n \"0.6221927\",\n \"0.6221927\",\n \"0.61935693\",\n \"0.61902726\",\n \"0.6185412\",\n \"0.61813194\",\n \"0.6169025\",\n \"0.6160391\",\n \"0.6156622\",\n \"0.6137323\",\n \"0.6126727\",\n \"0.6113291\",\n \"0.6108429\",\n \"0.61025006\",\n \"0.6096889\",\n \"0.6085063\",\n \"0.6084808\",\n \"0.60712713\",\n \"0.60656816\",\n \"0.6059236\",\n \"0.605465\",\n \"0.604833\",\n \"0.6042607\",\n \"0.6016483\",\n \"0.59988004\",\n \"0.59960717\",\n \"0.5995823\",\n \"0.5976453\",\n \"0.5976264\",\n \"0.5967838\",\n \"0.5962056\",\n \"0.59535813\",\n \"0.5945487\",\n \"0.5924718\",\n \"0.59099644\",\n \"0.59070736\",\n \"0.58992547\",\n \"0.5895074\",\n \"0.5848422\",\n \"0.5848422\",\n \"0.5848422\",\n \"0.5848422\",\n \"0.5848422\",\n \"0.5848422\",\n \"0.5841469\",\n \"0.58357006\",\n \"0.58246833\",\n \"0.5811975\",\n \"0.58106863\",\n \"0.5807386\",\n \"0.57971436\",\n \"0.57926047\",\n \"0.57898843\",\n \"0.5784179\",\n \"0.57753944\",\n \"0.5771162\",\n \"0.57689476\",\n \"0.5757701\",\n \"0.57539934\",\n \"0.5752122\",\n \"0.5751116\",\n \"0.5742965\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3189,"cells":{"query":{"kind":"string","value":"Material saver. Saves material and their properties the JSON file for type building elements. If the Project parent is set, it automatically saves it to the file given in Project.data. Alternatively you can specify a path to a file with Materials. If this file does not exist, a new file is created."},"document":{"kind":"string","value":"def save_material(material, data_class):\n data_class.material_bind[\"version\"] = \"0.7\"\n add_to_json = True\n\n warning_text = (\"Material with same name and same properties already \"\n \"exists in JSON, consider this material or revising your \"\n \"properties\")\n\n for id, check in data_class.material_bind.items():\n if id != \"version\":\n if check[\"name\"] == material.name and \\\n check[\"density\"] == material.density and \\\n check[\"thermal_conduc\"] == material.thermal_conduc and \\\n check[\"heat_capac\"] == material.heat_capac and \\\n check[\n \"thickness_default\"] == material.thickness_default and \\\n check[\"thickness_list\"] == material.thickness_list:\n\n warnings.warn(warning_text)\n print(material.name)\n add_to_json = False\n break\n\n if add_to_json is True:\n data_class.material_bind[\n material.material_id] = collections.OrderedDict()\n data_class.material_bind[\n material.material_id][\"name\"] = material.name\n data_class.material_bind[\n material.material_id][\"density\"] = material.density\n data_class.material_bind[\n material.material_id][\"thermal_conduc\"] = material.thermal_conduc\n data_class.material_bind[\n material.material_id][\"heat_capac\"] = material.heat_capac\n data_class.material_bind[\n material.material_id][\n \"thickness_default\"] = material.thickness_default\n data_class.material_bind[\n material.material_id][\"thickness_list\"] = material.thickness_list\n data_class.material_bind[\n material.material_id][\"solar_absorp\"] = material.solar_absorp\n\n with open(utilities.get_full_path(data_class.path_mat), 'w') as file:\n file.write(json.dumps(\n data_class.material_bind,\n indent=4,\n separators=(',', ': ')))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def save_material(filename, mat):\n out = np.array([mat.wav, mat.eps.real, mat.eps.imag,\n mat.mu.real, mat.mu.imag]).T\n header = \"Wavelength\\teps_real\\teps_imag\\tmu_real\\tmu_imag\"\n miepy.array_io.save(filename, out, header=header)","def WriteStructuralMaterialsjson(save_path,dic_in_json_format):\n complete_name=os.path.join(save_path,\"StructuralMaterials.json\") \n with open(complete_name, \"w\") as save_file:\n save_file.write(dic_in_json_format)\n if(DEBUG):\n print(\"StructuralMaterials.json written\")","def save_and_reload_scene():\n\n flg = logging.getLogger(\"lettuce.xgenSetup.save_and_reload_scene\")\n\n current_file = mc.file(save=True)\n flg.info(\"Current File: {}\".format(current_file))\n mc.file(current_file, ignoreVersion=True, open=True, force=True)","def export_material(self, bo, bm):\n\n # Sometimes, a material might need to be single-use. Right now, the most apparent example\n # of that situation is when a lightmap image is baked. Wavesets are in the same boat, but\n # that's a special case as of the writing of this code.\n single_user = self._requires_single_user_material(bo, bm)\n if single_user:\n mat_name = \"{}_AutoSingle\".format(bm.name) if bo.name == bm.name else \"{}_{}\".format(bo.name, bm.name)\n self._report.msg(\"Exporting Material '{}' as single user '{}'\", bm.name, mat_name, indent=1)\n hgmat = None\n else:\n mat_name = bm.name\n self._report.msg(\"Exporting Material '{}'\", mat_name, indent=1)\n hsgmat = self._mgr.find_key(hsGMaterial, name=mat_name, bl=bo)\n if hsgmat is not None:\n return hsgmat\n\n hsgmat = self._mgr.add_object(hsGMaterial, name=mat_name, bl=bo)\n slots = [(idx, slot) for idx, slot in enumerate(bm.texture_slots) if self._can_export_texslot(slot)]\n\n # There is a major difference in how Blender and Plasma handle stencils.\n # In Blender, the stencil is on top and applies to every layer below is. In Plasma, the stencil\n # is below the SINGLE layer it affects. The main texture is marked BindNext and RestartPassHere.\n # The pipeline indicates that we can render 8 layers simultaneously, so we will collect all\n # stencils and apply this arrangement. We're going to limit to 6 stencils however. 1 layer for\n # main texture and 1 piggyback.\n num_stencils = sum((1 for i in slots if i[1].use_stencil))\n if num_stencils > _MAX_STENCILS:\n raise ExportError(\"Material '{}' uses too many stencils. The maximum is {}\".format(bm.name, _MAX_STENCILS))\n stencils = []\n restart_pass_next = False\n\n # Loop over layers\n for idx, slot in slots:\n # Prepend any BumpMapping magic layers\n if slot.use_map_normal:\n if bo in self._bump_mats:\n raise ExportError(\"Material '{}' has more than one bumpmap layer\".format(bm.name))\n du, dw, dv = self.export_bumpmap_slot(bo, bm, hsgmat, slot, idx)\n hsgmat.addLayer(du.key) # Du\n hsgmat.addLayer(dw.key) # Dw\n hsgmat.addLayer(dv.key) # Dv\n\n if slot.use_stencil:\n stencils.append((idx, slot))\n else:\n tex_layer = self.export_texture_slot(bo, bm, hsgmat, slot, idx)\n if restart_pass_next:\n tex_layer.state.miscFlags |= hsGMatState.kMiscRestartPassHere\n restart_pass_next = False\n hsgmat.addLayer(tex_layer.key)\n if slot.use_map_normal:\n self._bump_mats[bo] = (tex_layer.UVWSrc, tex_layer.transform)\n # After a bumpmap layer(s), the next layer *must* be in a\n # new pass, otherwise it gets added in non-intuitive ways\n restart_pass_next = True\n if stencils:\n tex_state = tex_layer.state\n if not tex_state.blendFlags & hsGMatState.kBlendMask:\n tex_state.blendFlags |= hsGMatState.kBlendAlpha\n tex_state.miscFlags |= hsGMatState.kMiscRestartPassHere | hsGMatState.kMiscBindNext\n curr_stencils = len(stencils)\n for i in range(curr_stencils):\n stencil_idx, stencil = stencils[i]\n stencil_name = \"STENCILGEN_{}@{}_{}\".format(stencil.name, bm.name, slot.name)\n stencil_layer = self.export_texture_slot(bo, bm, hsgmat, stencil, stencil_idx, name=stencil_name)\n if i+1 < curr_stencils:\n stencil_layer.state.miscFlags |= hsGMatState.kMiscBindNext\n hsgmat.addLayer(stencil_layer.key)\n\n # Plasma makes several assumptions that every hsGMaterial has at least one layer. If this\n # material had no Textures, we will need to initialize a default layer\n if not hsgmat.layers:\n layer = self._mgr.find_create_object(plLayer, name=\"{}_AutoLayer\".format(bm.name), bl=bo)\n self._propagate_material_settings(bm, layer)\n hsgmat.addLayer(layer.key)\n\n # Cache this material for later\n mat_list = self._obj2mat.setdefault(bo, [])\n mat_list.append(hsgmat.key)\n\n # Looks like we're done...\n return hsgmat.key","def saveCallback(self):\n\n ## TODO // TEST IT\n self._pathsDict[\"sceneFile\"] = self.getSceneFile()\n try:\n openSceneInfo = self.getOpenSceneInfo()\n if not openSceneInfo:\n return\n except TypeError:\n return\n if openSceneInfo[\"jsonFile\"]:\n jsonInfo = self._loadJson(openSceneInfo[\"jsonFile\"])\n if jsonInfo[\"ReferenceFile\"]:\n absRefFile = os.path.join(self._pathsDict[\"projectDir\"], jsonInfo[\"ReferenceFile\"])\n # TODO : ref => Dict\n absBaseSceneVersion = os.path.join(self._pathsDict[\"projectDir\"], jsonInfo[\"Versions\"][int(jsonInfo[\"ReferencedVersion\"]) - 1][\"RelativePath\"])\n # if the refererenced scene file is the saved file (saved or saved as)\n if self._pathsDict[\"sceneFile\"] == absBaseSceneVersion:\n # copy over the forReference file\n try:\n shutil.copyfile(self._pathsDict[\"sceneFile\"], absRefFile)\n print \"Scene Manager Update:\\nReference File Updated\"\n except:\n pass","def menu_save_scene(self):\n file_name = QtGui.QFileDialog().getSaveFileName(self, \"Save Scene to File\", get_data_path(), \"*.pkl\")\n with open(file_name, \"wb\") as f:\n pickle.dump(self.scene, f, pickle.HIGHEST_PROTOCOL)","def save(self, filename=None):\n if filename is None:\n filename = \"morse_smale_complex.json\"\n with open(filename, \"w\") as fp:\n fp.write(self.to_json())","def savemat(self, file_name, mdict=None, appendmat=True, **kwargs):\n # Set mdict default value to empty dictionary\n if mdict is None:\n mdict = {}\n\n # Merge mdict with attributes dictionary, giving mdict the upper-hand\n # in case of inconsistency\n dsavemat = {**vars(self), **mdict}\n\n # Save the merged dictionary to a .mat file\n scipy.io.savemat(file_name, dsavemat, appendmat, **kwargs)","def AssembleStructuralMaterialsJson(KratosWindowManager):\n for key in KratosWindowManager.MatSave.keys():\n if(DEBUG):\n print(key)\n print(type(KratosWindowManager.MatSave[key]))\n sm.structuralmaterials_dict[\"properties\"][0][\"Material\"][\"Variables\"][key]=KratosWindowManager.MatSave[key]\n for bclistobject in KratosWindowManager.boundaryConditionEditor:\n if(DEBUG):\n print(bclistobject.name)\n if bclistobject.entityType=='Element':\n sm.structuralmaterials_dict[\"properties\"][0][\"model_part_name\"]=bclistobject.name\n\n\n if KratosWindowManager.is2D:\n sm.structuralmaterials_dict[\"properties\"][0][\"Material\"][\"constitutive_law\"][\"name\"]=\"KratosMultiphysics.StructuralMechanicsApplication.LinearElasticPlaneStrain2DLaw\"\n else:\n sm.structuralmaterials_dict[\"properties\"][0][\"Material\"][\"constitutive_law\"][\"name\"]=\"KratosMultiphysics.StructuralMechanicsApplication.LinearElastic3DLaw\"\n \n\n if(DEBUG):\n print(sm.structuralmaterials_dict)\n return sm.WriteMaterialToJson(sm.structuralmaterials_dict)","def test_save_materials(temp_dir):\n image1 = [[[0, 0, 0], [0, 0, 0]], [[255, 255, 255], [255, 255, 255]]]\n image2 = [[[0, 0, 0], [255, 255, 255]], [[255, 255, 255], [0, 0, 0]]]\n image3 = [[[255, 255, 255], [255, 255, 255]], [[0, 0, 0], [0, 0, 0]]]\n\n data = [\n (\"image1.png\", Image.fromarray(np.array(image1, dtype=np.uint8))),\n (\"image2.png\", Image.fromarray(np.array(image2, dtype=np.uint8))),\n (\"image3.png\", Image.fromarray(np.array(image3, dtype=np.uint8))),\n ]\n save_materials(temp_dir, data, step=1)\n\n assert os.path.exists(os.path.join(temp_dir, \"images\", \"1\", \"image1.png\"))\n assert os.path.exists(os.path.join(temp_dir, \"images\", \"1\", \"image2.png\"))\n assert os.path.exists(os.path.join(temp_dir, \"images\", \"1\", \"image3.png\"))","def read_material_data(self, material):\n material_yaml_file = glob.glob(os.path.join(material_dir, material + '.yaml'))\n\n inputs = utilities.yaml_reader(material_yaml_file, material_dir, material)\n self.name = inputs['Name']\n self.materialName = material\n self.elements = inputs['Elements']\n self.zaids = inputs['Elemental ZAIDs']\n self.weightFraction = inputs['Elemental Weight Fractions'] if 'Elemental Weight Fractions' in inputs else []\n self.enrichmentZaids = inputs['Elemental Adjustment ZAIDs'] if 'Elemental Adjustment ZAIDs' in inputs else []\n self.enrichmentIsotopes = inputs['Isotopic Adjustment ZAIDs'] if 'Isotopic Adjustment ZAIDs' in inputs else []\n self.enrichmentVector = inputs['Isotopic Weight Percents'] if 'Isotopic Weight Percents' in inputs else []\n self.isotopicAtomPercents = inputs['Isotopic Atom Percents'] if 'Isotopic Atom Percents' in inputs else []\n self.density = inputs['Density']\n self.linearCoeffExpansion = inputs['Linear Coefficient of Expansion']","def save_meta(self):\n # jOut = os.path.join(self.meta[\"wdir\"], meta_file)\n with open(self.meta_filepath, \"w\") as f:\n json.dump(self.meta, f)","def write_savefile(state: PhysicsState, file: Path):\n if file.suffix.lower() != '.json':\n # Ensure a .json suffix.\n file = file.parent / (file.name + '.json')\n log.info(f'Saving to savefile {file.resolve()}')\n\n savefile_json_dict = google.protobuf.json_format.MessageToDict(\n state.as_proto(),\n including_default_value_fields=False,\n preserving_proto_field_name=True,\n use_integers_for_enums=False,\n )\n\n for i, component in enumerate(savefile_json_dict['engineering']['components']):\n component['name'] = strings.COMPONENT_NAMES[i]\n\n with open(file, 'w') as outfile:\n json.dump(savefile_json_dict, outfile, indent=2)\n\n return file","def set_material(properties,object,finish,normal):\n if object not in properties:\n properties[object.getName()]={}\n properties[object.getName()][\"finish\"]=finish\n properties[object.getName()][\"normal\"]=normal","def write_saver_defs(self):\n assert self.savers_constructed\n full_saver_def = self.full_saver.as_saver_def()\n full_file = self.params.save_dir+self.params.model_name+\"_v\"+self.params.version+\".def\"\n with open(full_file, \"wb\") as f:\n f.write(full_saver_def.SerializeToString())\n self.logger.log_info(\"Full saver def saved in file %s\"%full_file)","def save(self):\n for name, param in self.components.items():\n param_path = os.path.join(self.model_path, \"%s.mat\" % name)\n if hasattr(param, 'params'):\n param_values = {p.name: p.get_value() for p in param.params}\n else:\n param_values = {name: param.get_value()}\n scipy.io.savemat(param_path, param_values)","def write_mat_file(self):\n mat_dict = {}\n mat_dict['Lx_p'] = self.Lx_p\n mat_dict['Ly_p'] = self.Ly_p\n mat_dict['Lz_p'] = self.Lz_p\n mat_dict['Lo'] = self.obst.get_Lo()\n mat_dict['Ny_divs'] = self.N_divs\n mat_dict['rho_p'] = self.rho_p\n mat_dict['nu_p'] = self.nu_p\n mat_dict['snl'] = list(np.union1d(self.obst_list[:],self.solid_list[:]))\n mat_dict['inl'] = list(self.inlet_list[:])\n mat_dict['onl'] = list(self.outlet_list[:])\n\n scipy.io.savemat('geometry_description',mat_dict)","def make_settings():\n settings = {}\n num_of_rocks = 1\n\n obj = json.load(open('assets/add_mesh_rocks.json'))\n presets = [obj[\"settings\"][\"default\"]] + obj[\"settings\"][\"preset\"]\n\n for preset in presets:\n title = preset[\"title\"]\n # SIZE\n size = preset[\"size\"]\n\n x, y, z = size[\"scale\"]\n if title == \"Default\":\n scale = uniform(float(x[\"lower\"]), float(x[\"upper\"]))\n scale_X = [scale, scale]\n scale_Y = [scale, scale]\n scale_Z = [scale, scale]\n else:\n scale_X = [float(x[\"lower\"]), float(x[\"upper\"])]\n scale_Y = [float(y[\"lower\"]), float(y[\"upper\"])]\n scale_Z = [float(z[\"lower\"]), float(z[\"upper\"])]\n\n x, y, z = size[\"skew\"]\n skew_X = float(x[\"value\"])\n skew_Y = float(y[\"value\"])\n skew_Z = float(z[\"value\"])\n\n scale_fac = ast.literal_eval(size[\"scale_fac\"])\n use_scale_dis = bool(size[\"use_scale_dis\"])\n\n # SHAPE\n shape = preset[\"shape\"]\n\n deform = float(shape[\"deform\"])\n rough = float(shape[\"rough\"])\n detail = float(shape[\"detail\"])\n display_detail = float(shape[\"display_detail\"])\n smooth_fac = float(shape[\"smooth_fac\"])\n smooth_it = float(shape[\"smooth_it\"])\n\n\n # MATERIAL\n material = preset[\"material\"]\n \n mat_enable = bool(material[\"mat_enable\"])\n mat_color = ast.literal_eval(material[\"mat_color\"])\n mat_bright = float(material[\"mat_bright\"])\n mat_rough = float(material[\"mat_rough\"])\n mat_spec = float(material[\"mat_spec\"])\n mat_hard = float(material[\"mat_hard\"])\n mat_use_trans = bool(material[\"mat_use_trans\"])\n mat_alpha = float(material[\"mat_alpha\"])\n mat_cloudy = float(material[\"mat_cloudy\"])\n mat_IOR = float(material[\"mat_IOR\"])\n mat_mossy = float(material[\"mat_mossy\"])\n\n # RANDOM\n random = preset[\"random\"]\n\n use_generate = bool(random[\"use_generate\"])\n use_random_seed = bool(random[\"use_random_seed\"])\n user_seed = float(random[\"user_seed\"])\n\n\n settings[title] = [\n context,\n scale_X,\n skew_X,\n scale_Y,\n skew_Y,\n scale_Z,\n skew_Z,\n scale_fac,\n detail,\n display_detail,\n deform,\n rough,\n smooth_fac,\n smooth_it,\n mat_enable,\n mat_color,\n mat_bright,\n mat_rough,\n mat_spec,\n mat_hard,\n mat_use_trans,\n mat_alpha,\n mat_cloudy,\n mat_IOR,\n mat_mossy,\n num_of_rocks,\n user_seed,\n False,\n use_random_seed\n ]\n\n return settings","def _save(self):\n\n out_dict = {}\n out_dict[\"version\"] = pyfx.__version__\n out_dict[\"name\"] = self._name\n out_dict[\"src\"] = self._src\n\n # Write out the background file as an image\n bg_file = os.path.join(self._name,\"master_bg_image.png\")\n pyfx.util.to_file(self._bg_frame,bg_file)\n out_dict[\"bg_frame\"] = bg_file\n\n f = open(os.path.join(self._name,\"pyfx.json\"),\"w\")\n json.dump(out_dict,f)\n f.close()","def append_material(self, material):\n # First check if asset attribute exists; if not, define the asset attribute\n if not hasattr(self, \"asset\"):\n self.asset = ET.Element(\"asset\")\n # If the material name is not in shared materials, add this to our assets\n if material.name not in self.shared_materials:\n self.asset.append(ET.Element(\"texture\", attrib=material.tex_attrib))\n self.asset.append(ET.Element(\"material\", attrib=material.mat_attrib))\n # Add this material name to shared materials if it should be shared\n if material.shared:\n self.shared_materials.add(material.name)\n self.shared_textures.add(material.tex_attrib[\"name\"])\n # Update prefix for assets\n add_prefix(root=self.asset, prefix=self.naming_prefix, exclude=self.exclude_from_prefixing)","def build_storage(self, mine, planet=None):\n self.send_build_post(\"resources\", planet, codes.storage[mine])","def save(self):\n if self.loaded:\n list_embeddingNames = [self.embeddings.vsm_name, self.synset_embeddings.vsm_name, self.imagined_embeddings.vsm_name]\n full_file_name = self.resource_manager.get_multimodal_dataset(self.corpus, list_embeddingNames)\n logging.info('Saving dataset to [%s]', full_file_name)\n with lzma.open(full_file_name, 'wb') as f:\n pickle.dump(self, f)\n else:\n logging.error('Dataset not loaded, call \"build\" method first!')","def save(self):\n memento = self.create_memento()\n import datetime\n f = open(str(datetime.datetime.now()).replace(' ','_')+'.saved_story','w')\n cPickle.dump(memento,f)\n f.close()\n zcanvas.message(\"Saved!\")","def save(self, path=''):\n if not self.__isBuilt:\n self._rebuild()\n if not path:\n self.w.save(self.path)\n else:\n if not path.endswith('.shp'):\n path = os.path.splitext(path)[0] + '.shp'\n self.w.save(path)","def serialize(file):\n global root_dir\n global wells_list\n global tops_list\n global project_file\n project_file = file\n\n current_project = Project(root_dir, wells_list, tops_list, file)\n f = open(file, 'wb')\n pickle.dump(current_project, f)","def persist(self) -> None:\n logger.info('Generating or Updating meta data file {}'.format(self.file_path))\n with open(self.file_path, 'w', encoding='utf-8') as meta_file:\n meta_file.write(json.dumps(self, default=lambda value: value.__dict__))","def create_blender_material(self, ogremat, mat, meshId, matIdx):\n logger.debug(\"create_blender_material\")\n textures = ogremat.textures\n bmat = None\n idx = 0\n mat_name = mat[\"name\"].split(\"/\")[0]\n try:\n bmat = bpy.data.materials[mat_name]\n if bversion == 3:\n bmat.name = \"tobedeleted\"\n bmat = bpy.data.materials.new(mat_name)\n except:\n bmat = bpy.data.materials.new(mat_name)\n self.set_uuid(bmat, ogremat.uuid)\n # material base properties\n if ogremat.doambient:\n if bversion == 2:\n bmat.setAmb(ogremat.ambient)\n else:\n bmat.ambient = ogremat.ambient\n if ogremat.specular:\n if bversion == 2:\n bmat.setSpec(1.0)\n bmat.setSpecCol(ogremat.specular[:3])\n bmat.setHardness(int(ogremat.specular[3]*4.0))\n else:\n bmat.specular_intensity = 1.0\n ogremat.specular[:3]\n bmat.specular_color = ogremat.specular[:3]\n bmat.specular_hardness = int(ogremat.specular[3]*4.0)\n if ogremat.alpha < 1.0:\n bmat.alpha = ogremat.alpha\n # specular\n for layerName, textureId in ogremat.layers.items():\n if layerName == 'shadowMap':\n if bversion == 2:\n bmat.setMode(Blender.Material.Modes['SHADOWBUF'] & bmat.getMode())\n else:\n bmat.use_cast_buffer_shadows = True\n if textureId:\n textureId = textureId\n pars = (bmat, layerName, mat[\"name\"], ogremat, idx, meshId,\n matIdx)\n if textureId in self._imported_assets:\n btex = self._imported_assets[textureId]\n self.layer_ready(btex, *pars)\n elif self.simrt:\n pars = (textureId,) + pars\n if not self.Asset.downloadAsset(textureId, 0,\n self.texture_downloaded, \n pars,\n main=self.doTextureDownloadTranscode):\n self.add_texture_callback(textureId, self.layer_ready, pars[1:])\n idx += 1\n self._imported_materials[mat[\"name\"]] = bmat\n return bmat","def saveSettings(self):\n self.genFiles.applyData()\n self.genGraph.applyData()","def __render_material_preview(self, scene):\n\n # Don't render material thumbnails.\n (width, height) = util.get_render_resolution(scene)\n if width <= 96:\n return\n\n # Collect objects and their materials in a object -> [materials] dictionary.\n objects_materials = {}\n for obj in (obj for obj in scene.objects if obj.is_visible(scene) and not obj.hide_render):\n for mat in util.get_instance_materials(obj):\n if mat is not None:\n if obj.name not in objects_materials.keys():\n objects_materials[obj] = []\n objects_materials[obj].append(mat)\n\n # Find objects that are likely to be the preview objects.\n preview_objects = [o for o in objects_materials.keys() if o.name.startswith('preview')]\n if not preview_objects:\n return\n\n # Find the materials attached to the likely preview object.\n likely_materials = objects_materials[preview_objects[0]]\n if not likely_materials:\n return\n\n # Build the path to the output preview project.\n preview_output_dir = os.path.join(tempfile.gettempdir(), \"blenderseed\", \"material_preview\")\n preview_project_filepath = os.path.join(preview_output_dir, \"material_preview.appleseed\")\n\n # Create target directories if necessary.\n if not os.path.exists(preview_output_dir):\n try:\n os.makedirs(preview_output_dir)\n except os.error:\n self.report({\"ERROR\"}, \"The directory {0} could not be created. Check directory permissions.\".format(preview_output_dir))\n return\n\n # Copy assets from template project to output directory.\n preview_template_dir = os.path.join(os.sep.join(util.realpath(__file__).split(os.sep)[:-1]), \"mat_preview\")\n existing_files = os.listdir(preview_output_dir)\n for item in os.listdir(preview_template_dir):\n if item not in existing_files:\n copyfile(os.path.join(preview_template_dir, item), os.path.join(preview_output_dir, item))\n\n prev_mat = likely_materials[0]\n prev_type = prev_mat.preview_render_type.lower()\n\n # Export the project.\n writer = projectwriter.Writer()\n file_written = writer.export_preview(scene,\n preview_project_filepath,\n prev_mat,\n prev_type,\n width,\n height)\n if not file_written:\n print('Error while exporting. Check the console for details.')\n return\n\n # Render the project.\n self.__render_project_file(scene, preview_project_filepath)","def SaveJSON(self, filename):\n data = {\n 'files': self._files,\n 'ebuilds': self._ebuilds,\n }\n json.dump(data, open(filename, 'w'))","def save(self, path_or_file, strict=True, fmt='auto'):\n\n self.validate(strict=strict)\n\n with _open(path_or_file, mode='w', fmt=fmt) as fdesc:\n json.dump(self.__json__, fdesc, indent=2)","def create_main_saver_node(self, version):\n fps = 25\n if version:\n project = version.task.project\n fps = project.fps\n\n random_ref_id = uuid.uuid4().hex\n\n output_format_data = [\n {\n 'name': 'jpg',\n 'node_tree': {\n 'type': 'Saver',\n 'attr': {\n 'TOOLS_Name': self.output_node_name_generator('jpg'),\n },\n 'input_list': {\n 'Clip': self.output_path_generator(version, 'jpg'),\n 'CreateDir': 1,\n 'ProcessRed': 1,\n 'ProcessGreen': 1,\n 'ProcessBlue': 1,\n 'ProcessAlpha': 0,\n 'OutputFormat': 'JPEGFormat',\n 'JpegFormat.Quality': 85,\n },\n 'connected_to': {\n # 'ref_id': random_ref_id\n 'Input': {\n 'type': 'ColorCurves',\n 'ref_id': random_ref_id,\n 'input_list': {\n 'EditAlpha': 0.0,\n },\n 'connected_to': {\n 'Input': {\n 'type': 'CineonLog',\n 'input_list': {\n 'Mode': 1,\n # 'RedBlackLevel': 0.0,\n # 'RedWhiteLevel': 1023.0,\n 'RedFilmStockGamma': 1.0\n },\n }\n }\n }\n }\n },\n },\n {\n 'name': 'tga',\n 'node_tree': {\n 'type': 'Saver',\n 'attr': {\n 'TOOLS_Name': self.output_node_name_generator('tga'),\n },\n 'input_list': {\n 'Clip': self.output_path_generator(version, 'tga'),\n 'CreateDir': 1,\n 'ProcessRed': 1,\n 'ProcessGreen': 1,\n 'ProcessBlue': 1,\n 'ProcessAlpha': 0,\n 'OutputFormat': 'TGAFormat',\n },\n 'connected_to': {\n 'ref_id': random_ref_id\n }\n },\n },\n {\n 'name': 'exr',\n 'node_tree': {\n 'type': 'Saver',\n 'attr': {\n 'TOOLS_Name': self.output_node_name_generator('exr'),\n },\n 'input_list': {\n 'Clip': self.output_path_generator(version, 'exr'),\n 'CreateDir': 1,\n 'ProcessRed': 1,\n 'ProcessGreen': 1,\n 'ProcessBlue': 1,\n 'ProcessAlpha': 1,\n 'OutputFormat': 'OpenEXRFormat',\n 'OpenEXRFormat.Depth': 1, # 16-bit float\n 'OpenEXRFormat.RedEnable': 1,\n 'OpenEXRFormat.GreenEnable': 1,\n 'OpenEXRFormat.BlueEnable': 1,\n 'OpenEXRFormat.AlphaEnable': 1,\n 'OpenEXRFormat.ZEnable': 0,\n 'OpenEXRFormat.CovEnable': 0,\n 'OpenEXRFormat.ObjIDEnable': 0,\n 'OpenEXRFormat.MatIDEnable': 0,\n 'OpenEXRFormat.UEnable': 0,\n 'OpenEXRFormat.VEnable': 0,\n 'OpenEXRFormat.XNormEnable': 0,\n 'OpenEXRFormat.YNormEnable': 0,\n 'OpenEXRFormat.ZNormEnable': 0,\n 'OpenEXRFormat.XVelEnable': 0,\n 'OpenEXRFormat.YVelEnable': 0,\n 'OpenEXRFormat.XRevVelEnable': 0,\n 'OpenEXRFormat.YRevVelEnable': 0,\n 'OpenEXRFormat.XPosEnable': 0,\n 'OpenEXRFormat.YPosEnable': 0,\n 'OpenEXRFormat.ZPosEnable': 0,\n 'OpenEXRFormat.XDispEnable': 0,\n 'OpenEXRFormat.YDispEnable': 0,\n },\n 'connected_to': {\n 'ref_id': random_ref_id\n }\n }\n },\n {\n 'name': 'mp4',\n 'node_tree': {\n 'type': 'Saver',\n 'attr': {\n 'TOOLS_Name': self.output_node_name_generator('mp4'),\n },\n 'input_list': {\n 'Clip': self.output_path_generator(version, 'mp4'),\n 'CreateDir': 1,\n 'ProcessRed': 1,\n 'ProcessGreen': 1,\n 'ProcessBlue': 1,\n 'ProcessAlpha': 0,\n 'OutputFormat': 'QuickTimeMovies',\n 'ProcessMode': 'Auto',\n 'SaveFrames': 'Full',\n 'QuickTimeMovies.Compression': 'H.264_avc1',\n 'QuickTimeMovies.Quality': 95.0,\n 'QuickTimeMovies.FrameRateFps': fps,\n 'QuickTimeMovies.KeyFrames': 5,\n 'StartRenderScript': 'frames_at_once = comp:GetPrefs(\"Comp.Memory.FramesAtOnce\")\\ncomp:SetPrefs(\"Comp.Memory.FramesAtOnce\", 1)',\n 'EndRenderScript': 'comp:SetPrefs(\"Comp.Memory.FramesAtOnce\", frames_at_once)',\n },\n 'connected_to': {\n 'ref_id': random_ref_id\n }\n }\n },\n {\n 'name': 'mov',\n 'node_tree': {\n 'type': 'Saver',\n 'attr': {\n 'TOOLS_Name': self.output_node_name_generator('mov'),\n },\n 'input_list': {\n 'Clip': self.output_path_generator(version, 'mov'),\n 'CreateDir': 1,\n 'ProcessRed': 1,\n 'ProcessGreen': 1,\n 'ProcessBlue': 1,\n 'ProcessAlpha': 0,\n 'OutputFormat': 'QuickTimeMovies',\n 'ProcessMode': 'Auto',\n 'SaveFrames': 'Full',\n 'QuickTimeMovies.Compression': 'Apple ProRes 422 HQ_apch',\n 'QuickTimeMovies.Quality': 95.0,\n 'QuickTimeMovies.FrameRateFps': fps,\n 'QuickTimeMovies.KeyFrames': 5,\n\n 'QuickTimeMovies.LimitDataRate': 0.0,\n 'QuickTimeMovies.DataRateK': 1000.0,\n 'QuickTimeMovies.Advanced': 1.0,\n 'QuickTimeMovies.Primaries': 0.0,\n 'QuickTimeMovies.Transfer': 0.0,\n 'QuickTimeMovies.Matrix': 0.0,\n 'QuickTimeMovies.PixelAspectRatio': 0.0,\n 'QuickTimeMovies.ErrorDiffusion': 1.0,\n 'QuickTimeMovies.SaveAlphaChannel': 1.0,\n\n 'StartRenderScript': 'frames_at_once = comp:GetPrefs(\"Comp.Memory.FramesAtOnce\")\\ncomp:SetPrefs(\"Comp.Memory.FramesAtOnce\", 1)',\n 'EndRenderScript': 'comp:SetPrefs(\"Comp.Memory.FramesAtOnce\", frames_at_once)',\n\n\n\n },\n 'connected_to': {\n 'ref_id': random_ref_id\n }\n }\n },\n ]\n\n if version.task.type and version.task.type.name == 'Plate':\n # create a different type of outputs\n output_format_data = [\n {\n 'name': 'jpg',\n 'node_tree': {\n 'type': 'Saver',\n 'attr': {\n 'TOOLS_Name': self.output_node_name_generator('jpg'),\n },\n 'input_list': {\n 'Clip': self.output_path_generator(version, 'jpg'),\n 'CreateDir': 1,\n 'ProcessRed': 1,\n 'ProcessGreen': 1,\n 'ProcessBlue': 1,\n 'ProcessAlpha': 0,\n 'OutputFormat': 'JPEGFormat',\n 'JpegFormat.Quality': 85,\n },\n },\n },\n {\n 'name': 'exr',\n 'node_tree': {\n 'type': 'Saver',\n 'attr': {\n 'TOOLS_Name': self.output_node_name_generator('exr'),\n },\n 'input_list': {\n 'Clip': self.output_path_generator(version, 'exr'),\n 'CreateDir': 1,\n 'ProcessRed': 1,\n 'ProcessGreen': 1,\n 'ProcessBlue': 1,\n 'ProcessAlpha': 0,\n 'OutputFormat': 'OpenEXRFormat',\n 'OpenEXRFormat.Depth': 1, # 16-bit float\n 'OpenEXRFormat.RedEnable': 1,\n 'OpenEXRFormat.GreenEnable': 1,\n 'OpenEXRFormat.BlueEnable': 1,\n 'OpenEXRFormat.AlphaEnable': 0,\n 'OpenEXRFormat.ZEnable': 0,\n 'OpenEXRFormat.CovEnable': 0,\n 'OpenEXRFormat.ObjIDEnable': 0,\n 'OpenEXRFormat.MatIDEnable': 0,\n 'OpenEXRFormat.UEnable': 0,\n 'OpenEXRFormat.VEnable': 0,\n 'OpenEXRFormat.XNormEnable': 0,\n 'OpenEXRFormat.YNormEnable': 0,\n 'OpenEXRFormat.ZNormEnable': 0,\n 'OpenEXRFormat.XVelEnable': 0,\n 'OpenEXRFormat.YVelEnable': 0,\n 'OpenEXRFormat.XRevVelEnable': 0,\n 'OpenEXRFormat.YRevVelEnable': 0,\n 'OpenEXRFormat.XPosEnable': 0,\n 'OpenEXRFormat.YPosEnable': 0,\n 'OpenEXRFormat.ZPosEnable': 0,\n 'OpenEXRFormat.XDispEnable': 0,\n 'OpenEXRFormat.YDispEnable': 0,\n },\n },\n },\n {\n 'name': 'mp4',\n 'node_tree': {\n 'type': 'Saver',\n 'attr': {\n 'TOOLS_Name': self.output_node_name_generator('mp4'),\n },\n 'input_list': {\n 'Clip': self.output_path_generator(version, 'mp4'),\n 'CreateDir': 1,\n 'ProcessRed': 1,\n 'ProcessGreen': 1,\n 'ProcessBlue': 1,\n 'ProcessAlpha': 0,\n 'OutputFormat': 'QuickTimeMovies',\n 'ProcessMode': 'Auto',\n 'SaveFrames': 'Full',\n 'QuickTimeMovies.Compression': 'H.264_avc1',\n 'QuickTimeMovies.Quality': 95.0,\n 'QuickTimeMovies.FrameRateFps': fps,\n 'QuickTimeMovies.KeyFrames': 5,\n 'StartRenderScript': 'frames_at_once = comp:GetPrefs(\"Comp.Memory.FramesAtOnce\")\\ncomp:SetPrefs(\"Comp.Memory.FramesAtOnce\", 1)',\n 'EndRenderScript': 'comp:SetPrefs(\"Comp.Memory.FramesAtOnce\", frames_at_once)',\n },\n },\n },\n ]\n\n # selectively generate output format\n saver_nodes = self.get_main_saver_node()\n\n for data in output_format_data:\n format_name = data['name']\n node_tree = data['node_tree']\n\n # now check if a node with the same name exists\n format_node = None\n format_node_name = self.output_node_name_generator(format_name)\n for node in saver_nodes:\n node_name = node.GetAttrs('TOOLS_Name')\n if node_name.startswith(format_node_name):\n format_node = node\n break\n\n # create the saver node for this format if missing\n if not format_node:\n self.create_node_tree(node_tree)\n else:\n # just update the input_lists\n if 'input_list' in node_tree:\n input_list = node_tree['input_list']\n for key in input_list:\n node_input_list = format_node.GetInputList()\n for input_entry_key in node_input_list.keys():\n input_entry = node_input_list[input_entry_key]\n input_id = input_entry.GetAttrs()['INPS_ID']\n if input_id == key:\n value = input_list[key]\n input_entry[0] = value\n break\n\n try:\n os.makedirs(\n os.path.dirname(\n self.output_path_generator(version, format_name)\n )\n )\n except OSError:\n # path already exists\n pass","def _saveProjects(self, data):\n logger.debug(\"Func: _saveProjects %s\")\n\n self._dumpJson(data, self._pathsDict[\"projectsFile\"])","def dump_mat(filename, obj, **kwargs):\n return sio.savemat(filename, obj, **kwargs)","def save(self, path):\n\n with open(path, \"w\") as f:\n json.dump(self.definition, f, separators=(\",\", \":\"), cls=JSONEncoder)","def save(self, path):\n\n with open(path, \"w\") as f:\n json.dump(self.definition, f, separators=(\",\", \":\"), cls=JSONEncoder)","def save_settings(self):\n settings = {'camera': self.comboCamera.currentIndex(),\n 'rotation': self.comboRotation.currentIndex(),\n 'colors': {\n 'min_hue': self.spinMinHue.value(),\n 'max_hue': self.spinMaxHue.value(),\n 'min_saturation': self.spinMinSaturation.value(),\n 'max_saturation': self.spinMaxSaturation.value(),\n 'min_value': self.spinMinValue.value(),\n 'max_value': self.spinMaxValue.value(),\n }, 'diameter': self.spinDiameter.value(),\n 'lifter': self.lineEditLifter.text(),\n 'save_video': self.checkSaveVideo.isChecked()\n }\n settings_file = open('./resources/settings.json', 'w')\n json.dump(settings, settings_file, indent=4)\n settings_file.close()\n self.statusbar.clearMessage()\n self.statusbar.showMessage('Settings saved.', 5000)","def save_(self):\n if not self._edited:\n return\n data = {'history': self.dump()}\n with open(os.path.join(os.path.dirname(self.arch_handler.dicomdir_path), self.SAVE_NAME), \"w\") as outfile:\n json.dump(data, outfile)\n self._edited = False","def save(self, filepath):\n writer = json.dump if Config.isjson(filepath) else yaml.dump\n with open(filepath, 'w') as f:\n writer(dict(self), f)","def save(self):\n if self.loaded:\n full_file_name = self.resource_manager.get_dataset(self.corpus, self.embeddings.vsm_name)\n logging.info('Saving dataset to [%s]', full_file_name)\n with lzma.open(full_file_name, 'wb') as f:\n pickle.dump(self, f)\n else:\n logging.error('Dataset not loaded, call \"build\" method first!')","def save(self):\n with open(str(self._path.resolve()), 'w+') as f:\n json.dump(self._database, f, indent=4)\n return self","def AddMaterial(self, *args):\n return _XCAFDoc.XCAFDoc_MaterialTool_AddMaterial(self, *args)","def loadMaterial(self):\n\t\tif not os.path.exists(down_dir):\n\t\t\traise TypeError(\"Directory 'downloads' with application materials must exist\")\n\n\t\tfor filename in glob.glob(down_dir + self.id+ \"*\"):\n\t\t\tdestination = self.dir + \"/\"+ filename[(len(self.id)+11)::]\n\t\t\tos.rename(filename, destination)","def save_scene(force=True, **kwargs):\n\n pass","def save(self):\n with open(FileStorage.__file_path, 'w') as saves:\n copy_dict = {key: self.__objects[key].to_dict()\n for key in self.__objects}\n json.dump(copy_dict, saves)","def save(self):\n a_copy = FileStorage.__objects\n obj_dict = {obj: a_copy[obj].to_dict() for obj in a_copy.keys()}\n with open(FileStorage.__file_path, \"w\") as f:\n json.dump(obj_dict, f)","def save(self, path):\n if not is_dry():\n with open(path, 'w') as f:\n json.dump(self.to_dict(), f, indent=4)\n return path","def materials_adding_panel(self, context):\r\n \r\n AM = context.window_manager.asset_m\r\n layout = self.layout\r\n box = layout.box()\r\n view = context.space_data\r\n thumbnails_path = get_directory('icons')\r\n library_path = get_library_path()\r\n extentions = (\".jpg\", \".jpeg\", \".png\")\r\n thumb = [thumb.rsplit(\".\", 1)[0] for thumb in listdir(thumbnails_path) if thumb.endswith(extentions)]\r\n if AM.as_mat_scene:\r\n thumb_list = thumb + [\"AM_Cloth\", \"AM_Sphere\"]\r\n else: \r\n thumb_list = thumb\r\n\r\n cam_is_valid = False\r\n obj_is_valid = False\r\n \r\n \r\n if not AM.as_mat_scene and not bpy.context.object:\r\n box.prop(AM, \"as_mat_scene\", text = \"Save as material scene\")\r\n box.label(\"No active_object in the scene\", icon='ERROR')\r\n box.operator(\"object.cancel_panel_choise\", text=\"Cancel\", icon='X')\r\n \r\n elif not AM.as_mat_scene and not bpy.context.active_object.active_material:\r\n box.prop(AM, \"as_mat_scene\", text = \"Save as material scene\")\r\n box.label(\"The object have no material\", icon='ERROR')\r\n box.operator(\"object.cancel_panel_choise\", text=\"Cancel\", icon='X')\r\n \r\n else:\r\n if AM.as_mat_scene and not isdir(join(library_path, 'materials', \"Render Scenes\")):\r\n box.operator(\"object.create_rder_scn_lib\", text = \"Create render scene library\", icon = 'FILESEL')\r\n box.operator(\"object.cancel_panel_choise\", text=\"Cancel\", icon='X')\r\n \r\n else:\r\n \r\n if AM.as_mat_scene:\r\n asset_name = AM.scene_name\r\n else:\r\n active_mat = context.active_object.active_material\r\n asset_name = active_mat.name\r\n \r\n if len(bpy.context.active_object.material_slots) == 1:\r\n AM.multi_materials = False\r\n \r\n if AM.as_mat_scene and (not asset_name in thumb_list or asset_name in thumb_list and AM.replace_rename == 'replace') or\\\r\n not AM.as_mat_scene and (AM.multi_materials and get_valid_materials() or not AM.multi_materials and asset_name not in thumb_list or asset_name in thumb_list and AM.replace_rename == 'replace'): \r\n if not AM.multi_materials:\r\n if asset_name in thumb_list and AM.replace_rename == 'replace':\r\n box.label(\"\\\" {} \\\" already exist\".format(asset_name), icon='ERROR')\r\n box.separator()\r\n if len(bpy.context.active_object.material_slots) >= 2 and AM.replace_rename == 'rename':\r\n box.prop(AM, \"multi_materials\", text = \"All materials\")\r\n row = box.row(align=True)\r\n row.prop(AM, \"replace_rename\", text=\" \", expand=True)\r\n if AM.replace_rename == 'rename':\r\n if AM.as_mat_scene:\r\n box.prop(AM, \"scene_name\", text = \"\")\r\n else:\r\n box.prop(AM, \"rename_mat\", text=\"\")\r\n \r\n box.prop(AM, \"as_mat_scene\", text = \"Save as material scene\")\r\n if not AM.as_mat_scene and len(bpy.context.active_object.material_slots) >= 2:\r\n if len(get_valid_materials()) != len(bpy.context.active_object.material_slots) and AM.multi_materials:\r\n box.label(\"Some materials wont be added\", icon = 'ERROR')\r\n box.label(\" because there already exist\")\r\n row = box.row()\r\n row.prop(AM, \"multi_materials\", text = \"All materials\")\r\n if AM.as_mat_scene:\r\n row = box.row(align = True)\r\n row.label(\"Scene name:\")\r\n row.prop(AM, \"scene_name\", text = \"\")\r\n \r\n row = box.row(align = True)\r\n row.prop(AM, \"render_type\", text = \" \", expand = True)\r\n row = box.row()\r\n row.label(\"Thumbnail extention:\")\r\n row = box.row(align = True)\r\n row.prop(AM, \"thumb_ext\", expand = True)\r\n \r\n if AM.as_mat_scene:\r\n for obj in context.scene.objects:\r\n if obj.type == 'CAMERA':\r\n cam_is_valid = True\r\n \r\n if len([obj for obj in context.selected_objects if obj.type != 'CAMERA' and bpy.context.active_object == obj]) == 1:\r\n obj_is_valid = True\r\n \r\n row = box.row()\r\n row.label(\"Selected object rendering\", icon = 'FILE_TICK' if obj_is_valid else 'CANCEL')\r\n row = box.row()\r\n row.label(\"Camera in the scene\", icon = 'FILE_TICK' if cam_is_valid else 'CANCEL')\r\n if not cam_is_valid:\r\n row = box.row()\r\n row.operator(\"object.camera_add\", text = \"Add camera\", icon = 'OUTLINER_OB_CAMERA')\r\n \r\n if not AM.as_mat_scene:\r\n # --------------------- # \r\n # RENDER THUMBNAIL #\r\n # --------------------- #\r\n \r\n if AM.render_type == 'render':\r\n row = box.row(align = True)\r\n row.label(\"Thumbnail:\")\r\n row.prop(AM, \"mat_thumb_type\", text = \"\")\r\n \r\n # --------------------- # \r\n # OPENGL THUMBNAIL #\r\n # --------------------- #\r\n \r\n if AM.render_type == 'opengl':\r\n row = box.row(align=True)\r\n row.operator(\"object.setup_ogl_render\", text=\"Setup OGL render\" if not \"AM_OGL_Camera\" in [obj.name for obj in context.scene.objects] else \"View camera\", icon='ZOOMIN')\r\n row.operator(\"object.remove_ogl_render\", text=\"\", icon='ZOOMOUT')\r\n row = layout.column()\r\n row = box.row(align=True) \r\n row.label(\"Background:\")\r\n row.prop(AM, \"background_alpha\", text=\"\")\r\n row = box.row(align=True)\r\n row.prop(view, \"show_only_render\")\r\n\r\n # -------------------- # \r\n # IMAGE THUMBNAIL #\r\n # -------------------- #\r\n \r\n elif AM.render_type == 'image':\r\n row = box.row(align=True)\r\n row.prop(AM, \"image_type\", text=\" \", expand=True)\r\n if AM.image_type == 'disk':\r\n box.label(\"Choose your thumbnail\")\r\n box.prop(AM, \"custom_thumbnail_path\", text=\"\")\r\n else:\r\n box.prop_search(AM, \"render_name\", bpy.data, \"images\", text=\"\") \r\n \r\n row = box.row(align=True)\r\n if (AM.as_mat_scene and AM.scene_name and cam_is_valid and obj_is_valid or not AM.as_mat_scene) and (AM.render_type == 'render' or (asset_name not in thumb_list or AM.replace_rename == 'replace') and AM.render_type == 'opengl' or AM.render_type == 'image' and (AM.image_type == 'disk' and AM.custom_thumbnail_path or AM.image_type == 'rendered' and AM.render_name)):\r\n if AM.as_mat_scene:\r\n row.operator(\"object.add_scene_in_library\", text=\"OK\", icon='FILE_TICK')\r\n else:\r\n row.operator(\"object.add_material_in_library\", text=\"OK\", icon='FILE_TICK')\r\n row.operator(\"object.cancel_panel_choise\", text=\"Cancel\", icon='X')\r\n \r\n else:\r\n if AM.multi_materials and not get_valid_materials():\r\n box.label(\"All materials already exist\".format(asset_name), icon='ERROR')\r\n box.separator()\r\n if len(bpy.context.active_object.material_slots) >= 2:\r\n box.prop(AM, \"multi_materials\", text = \"All materials\")\r\n \r\n else:\r\n box.label(\"\\\" {} \\\" already exist\".format(asset_name), icon='ERROR')\r\n box.separator()\r\n if len(bpy.context.active_object.material_slots) >= 2:\r\n box.prop(AM, \"multi_materials\", text = \"All materials\")\r\n else:\r\n AM.multi_materials = False\r\n row = box.row(align=True)\r\n row.prop(AM, \"replace_rename\", text=\" \", expand=True)\r\n if AM.replace_rename == 'rename':\r\n if AM.as_mat_scene:\r\n box.prop(AM, \"scene_name\", text = \"\")\r\n else:\r\n box.prop(AM, \"rename_mat\", text=\"\")\r\n \r\n row = box.row()\r\n row.operator(\"object.cancel_panel_choise\", text=\"Cancel\", icon='X')","def _save(self):\n with open(self.file_path, 'w') as fid:\n json.dump(self.data, fid, indent=4, sort_keys=True)","def set_save_building(self, positions, building, pick_up_vertical, side_number):\n current = self.get_save_buildings()\n exist = False\n for pos in positions:\n print([pos[0], pos[1]])\n\n # Check if there is a building with the same number saved already\n if len(current) > 0:\n for saved_building in current:\n print(saved_building.number)\n if saved_building.number == building:\n if saved_building.side_number == side_number:\n print(\"[ERROR] Side already exists!\")\n return\n\n # If it is a new building, create it and add it to the array\n if not exist:\n current.append(BuildingSide(positions, pick_up_vertical, building, side_number))\n print(\"[INFO] Saved building\")\n\n saved_file = open(self.file_name_building, \"w\")\n json.dump(json.dumps(current, default=lambda o: o.__dict__,\n sort_keys=True), saved_file)\n saved_file.close()","def write_mat_file(self, geom_filename):\n mat_dict = {}\n mat_dict['Lx_p'] = self.Lx_p\n mat_dict['Ly_p'] = self.Ly_p\n mat_dict['Lz_p'] = self.Lz_p\n mat_dict['Lo'] = self.obst.get_Lo()\n mat_dict['Ny_divs'] = self.N_divs\n mat_dict['rho_p'] = self.rho_p\n mat_dict['nu_p'] = self.nu_p\n mat_dict['snl'] = list(np.union1d(self.obst_list[:],self.solid_list[:]))\n mat_dict['inl'] = list(self.inlet_list[:])\n mat_dict['onl'] = list(self.outlet_list[:])\n\n scipy.io.savemat(geom_filename,mat_dict)","def save_configurations(self):\n # Get the file path\n self.data_path = self.data_path_entry.get()\n # Open the file\n with open(self.data_path, 'rb') as file:\n self.log('Opened ' + str(self.data_path))\n # Un-serialize\n info = pickle.load(file)\n # Write the new properties\n self.main_window.overwrite_properties(info)\n\n self.exit()","def save(filename, mat):\n if not isinstance(mat, np.ndarray):\n raise ValueError('for now, we can only save numpy arrays')\n return sio.savemat(filename, {'data': mat}, appendmat=False)","def _build_writer(self):\n # Create savers (one for current, one for best)\n self.saver_cur = tf.train.Saver()\n self.saver_best = tf.train.Saver()","def save_waveform(self, chan=None):\n t, y, pre = self.device.retrieve_current_waveform()\n meta = self.create_meta()\n if chan != None:\n meta['Channel'] = chan\n for name in pre:\n meta[name] = pre[name]\n data = {'meta' : meta,\n 't' : t,\n 'y' : y}\n rsp = daq.Rsp('save', data, meta)\n self.shot += 1\n self.r_queue.put(rsp)","def write_material_data(ka_red=255.0 / 255, ka_green=255.0 / 255, ka_blue=255.0 / 255,\n ka_texture_ID=9223372036854775807, # ambient\n ks_red=255.0 / 255, ks_green=255.0 / 255, ks_blue=255.0 / 255,\n ks_texture_ID=9223372036854775807, # specular\n kd_red=255.0 / 255, kd_green=255.0 / 255, kd_blue=255.0 / 255,\n kd_texture_ID=9223372036854775807, # diffuse\n ns=0.1, # specular exponent\n alpha=1 # opacity\n ):\n\n input_ = [(ka_red, 'float32'), (ka_green, 'float32'), (ka_blue, 'float32'),\n (ka_texture_ID, 'uint64'),\n (ks_red, 'float32'), (ks_green, 'float32'), (ks_blue, 'float32'),\n (ks_texture_ID, 'uint64'),\n (kd_red, 'float32'), (kd_green, 'float32'), (kd_blue, 'float32'),\n (kd_texture_ID, 'uint64'),\n (ns, 'float32'), (alpha, 'float32')]\n\n block_bytes = encode(input_)\n return block_bytes","def build_saver(self):\n #this is used to restore and save the graph default_saver.restore\n\n default_saver = tf.train.Saver(max_to_keep=3, allow_empty=True)\n self.savers = {self.name: default_saver}","def create_material_data(self):\n for num, zaid in enumerate(self.enrichmentZaids):\n enriched_isotope_dict = {}\n for isoNum, isotopes in enumerate(self.enrichmentIsotopes[num]):\n enriched_isotope_dict[isotopes] = self.enrichmentVector[num][isoNum]\n self.enrichmentDict[zaid] = enriched_isotope_dict\n for num, element in enumerate(self.elements):\n self.elementDict[self.zaids[num]] = Element.Element(element)\n\n if self.isotopicAtomPercents:\n self.atomDensity = self.density\n self.set_atom_fractions()\n else:\n self.set_elemental_enrichment()\n self.set_weight_percent()\n self.atomDensity, self.atomPercent = set_atom_percent(self.weightPercent, self.density,\n self.elementDict)","def save(self, settings=None):\n json_string = json.dumps(self.variables)\n with open(self.filepath, 'w', encoding='utf-8') as fh:\n fh.write(json_string)","def save_game(partie):\n fichier= open(\"save_game.json\",\"w\")\n json.dump(partie,fichier)\n fichier.close()","def get_save_buildings(self):\n saved_building = []\n print(\"Get saved buildings\")\n try:\n saved_file = open(self.file_name_building)\n try:\n data = json.loads(json.load(saved_file))\n for p in data:\n saved_building.append(\n BuildingSide(p.get(\"side\"), p.get(\"pick_up_vertical\"), p.get(\"number\"), p.get(\"side_number\")))\n\n except json.decoder.JSONDecodeError:\n saved_building = []\n\n saved_file.close()\n except FileNotFoundError:\n saved_building = []\n\n return saved_building","def save(self):\n with open(self.file_path, 'w', encoding=Config.ENCODING) as file:\n json.dump(self.data, file, indent=2, ensure_ascii=False)","def save(self):\r\n os.makedirs(self.settings.save_path, exist_ok=True)\r\n current_file = os.path.join(self.settings.save_path, 'current.json')\r\n if os.path.exists(current_file):\r\n raise FileExistsError()\r\n current_folder = os.path.join(self.settings.save_path, 'current')\r\n os.makedirs(current_folder, exist_ok=True)\r\n\r\n tosave = {\r\n 'generation': self.generation,\r\n 'approach_ind': self.approach[0],\r\n 'approach_params': Evolver._clean_params(self.approach_params),\r\n 'sensitive_params': Evolver._clean_params(self.sensitive_params)\r\n }\r\n\r\n with open(current_file, 'w') as outfile:\r\n json.dump(tosave, outfile)","def generate_file(material_id):\n apr=get_doc_from_MP(material_id)\n mat_list=generate_matrix(apr)\n formu=POSCAR_title(apr)\n cell_for=generate_cell_formula(apr)\n needed_dos=generate_dos_str(material_id)\n revise_dos=dos_into_string(needed_dos)\n ordered_list=generate_ordered_list(revise_dos)\n my_ordered_elements=generate_ordered_elements(revise_dos,ordered_list)\n my_ordered_numbers=generate_ordered_numbers(revise_dos,ordered_list,cell_for)\n generate_POSCAR(formu,mat_list,my_ordered_elements,my_ordered_numbers,revise_dos)","def saveBaseScene(self, categoryName, baseName, subProjectIndex=0, makeReference=True, versionNotes=\"\", sceneFormat=\"nk\", *args, **kwargs):\n logger.debug(\"Func: saveBaseScene\")\n\n now = datetime.datetime.now().strftime(\"%d/%m/%Y-%H:%M\")\n completeNote = \"[%s] on %s\\n%s\\n\" % (self.currentUser, now, versionNotes)\n\n # Check if the base name is unique\n scenesToCheck = self.scanBaseScenes(categoryAs=categoryName, subProjectAs=subProjectIndex)\n for key in scenesToCheck.keys():\n if baseName.lower() == key.lower():\n msg = (\"Base Scene Name is not unique!\\nABORTING\")\n self._exception(360, msg)\n return -1, msg\n\n projectPath = self.projectDir\n databaseDir = self._pathsDict[\"databaseDir\"]\n scenesPath = self._pathsDict[\"scenesDir\"]\n categoryPath = os.path.normpath(os.path.join(scenesPath, categoryName))\n self._folderCheck(categoryPath)\n\n ## if its going to be saved as a subproject\n if not subProjectIndex == 0:\n subProjectPath = os.path.normpath(os.path.join(categoryPath, self._subProjectsList[subProjectIndex]))\n self._folderCheck(subProjectPath)\n shotPath = os.path.normpath(os.path.join(subProjectPath, baseName))\n self._folderCheck(shotPath)\n\n jsonCategoryPath = os.path.normpath(os.path.join(databaseDir, categoryName))\n self._folderCheck(jsonCategoryPath)\n jsonCategorySubPath = os.path.normpath(os.path.join(jsonCategoryPath, self._subProjectsList[subProjectIndex]))\n self._folderCheck(jsonCategorySubPath)\n jsonFile = os.path.join(jsonCategorySubPath, \"{}.json\".format(baseName))\n\n else:\n shotPath = os.path.normpath(os.path.join(categoryPath, baseName))\n self._folderCheck(shotPath)\n\n jsonCategoryPath = os.path.normpath(os.path.join(databaseDir, categoryName))\n self._folderCheck(jsonCategoryPath)\n jsonFile = os.path.join(jsonCategoryPath, \"{}.json\".format(baseName))\n\n\n version = 1\n sceneName = \"{0}_{1}_{2}_v{3}\".format(baseName, categoryName, self._usersDict[self.currentUser], str(version).zfill(3))\n sceneFile = os.path.join(shotPath, \"{0}.{1}\".format(sceneName, sceneFormat))\n ## relativity update\n relSceneFile = os.path.relpath(sceneFile, start=projectPath)\n # killTurtle()\n # TODO // cmds may be used instead\n # pm.saveAs(sceneFile)\n nuke.scriptSaveAs(sceneFile)\n\n thumbPath = self.createThumbnail(dbPath=jsonFile, versionInt=version)\n\n jsonInfo = {}\n\n if makeReference:\n # TODO // Find an elegant solution and add MA compatibility. Can be merged with makeReference function in derived class\n referenceName = \"{0}_{1}_forReference\".format(baseName, categoryName)\n referenceFile = os.path.join(shotPath, \"{0}.{1}\".format(referenceName, sceneFormat))\n ## relativity update\n relReferenceFile = os.path.relpath(referenceFile, start=projectPath)\n shutil.copyfile(sceneFile, referenceFile)\n jsonInfo[\"ReferenceFile\"] = relReferenceFile\n jsonInfo[\"ReferencedVersion\"] = version\n else:\n jsonInfo[\"ReferenceFile\"] = None\n jsonInfo[\"ReferencedVersion\"] = None\n\n jsonInfo[\"ID\"] = \"SmNukeV02_sceneFile\"\n jsonInfo[\"NukeVersion\"] = [nuke.NUKE_VERSION_MAJOR, nuke.NUKE_VERSION_MINOR]\n jsonInfo[\"Name\"] = baseName\n jsonInfo[\"Path\"] = os.path.relpath(shotPath, start=projectPath)\n jsonInfo[\"Category\"] = categoryName\n jsonInfo[\"Creator\"] = self.currentUser\n jsonInfo[\"CreatorHost\"] = (socket.gethostname())\n jsonInfo[\"Versions\"] = [ # PATH => Notes => User Initials => Machine ID => Playblast => Thumbnail\n {\"RelativePath\": relSceneFile,\n \"Note\": completeNote,\n \"User\": self._usersDict[self.currentUser],\n \"Workstation\": socket.gethostname(),\n \"Preview\": {},\n \"Thumb\": thumbPath,\n \"Ranges\": self._getTimelineRanges()\n }\n ]\n\n jsonInfo[\"SubProject\"] = self._subProjectsList[subProjectIndex]\n self._dumpJson(jsonInfo, jsonFile)\n return [0, \"\"]","def save(self):\n with open(self.__file_path, \"w\", encoding=\"UTF-8\") as file:\n parsed_dict = {\n key: value.to_dict()\n for key, value in self.__objects.items()\n }\n save_data(parsed_dict, file)","def save(aircraft, settings):\n\n filepath = settings.paths('f_aircraft')\n logger.info(f\"Writing aircraft model to file '{truncate_filepath(filepath)}'...\")\n\n # ====== Aircraft top level =====\n output = {}\n output['uid'] = aircraft.uid\n\n output['refs'] = {}\n for key, value in aircraft.refs.items():\n output['refs'][key] = value\n\n # ====== Wings =====\n output['wings'] = []\n for wing in aircraft.wings.values():\n wing_entry = {}\n wing_entry['uid'] = wing.uid\n wing_entry['symmetry'] = wing.symmetry\n\n # ====== Segments =====\n wing_entry['segments'] = []\n for segment in wing.segments.values():\n segment_entry = {}\n segment_entry['uid'] = segment.uid\n segment_entry['vertices'] = dict(segment.vertices)\n\n segment_entry['geometry'] = {}\n for key, value in segment.geometry.items():\n segment_entry['geometry'][key] = value\n\n segment_entry['airfoils'] = {}\n for key, value in segment.airfoils.items():\n # If airfoil is \"blade\" file, make sure to save as relative path\n # Note: Airfoil definition may also be for instance \"NACA1234\"\n if \"blade.\" in value:\n # Make path relative!\n value = os.path.join(PATHS.DIR.AIRFOILS, os.path.basename(value))\n segment_entry['airfoils'][key] = value\n\n segment_entry['panels'] = {}\n for key, value in segment.panels.items():\n segment_entry['panels'][key] = value\n\n wing_entry['segments'].append(segment_entry)\n\n # ====== Controls =====\n wing_entry['controls'] = []\n for control in wing.controls.values():\n control_entry = {}\n\n control_entry['uid'] = control.uid\n control_entry['device_type'] = control.device_type\n control_entry['deflection'] = control.deflection\n control_entry['deflection_mirror'] = control.deflection_mirror\n\n control_entry['segment_uid'] = {}\n for key, value in control.segment_uid.items():\n control_entry['segment_uid'][key] = value\n\n control_entry['rel_vertices'] = {}\n for key, value in control.rel_vertices.items():\n control_entry['rel_vertices'][key] = value\n\n control_entry['rel_hinge_vertices'] = {}\n for key, value in control.rel_hinge_vertices.items():\n control_entry['rel_hinge_vertices'][key] = value\n\n control_entry['panels'] = {}\n for key, value in control.panels.items():\n control_entry['panels'][key] = value\n\n wing_entry['controls'].append(control_entry)\n\n output['wings'].append(wing_entry)\n\n with open(filepath, 'w') as fp:\n dump_pretty_json(output, fp)","def dumpme(self) :\n fileName = \"./data/oP4_ModelBuilder.dump\"\n with open(fileName,\"wb\") as dumpedFile:\n oPickler = pickle.Pickler(dumpedFile)\n oPickler.dump(self)","def save(self, json_path):\n with open(json_path, 'w') as f:\n json.dump(self.__dict__, f, indent = 4)","def save(self):\n # Create needed subfolder if not yet exist\n f = get_subfolder(f\"population{'_backup' if self.use_backup else ''}/storage/\", f'{self.folder_name}')\n if len(str(self).split(\"/\")) > 1: get_subfolder(f, f'{str(self).split(\"/\")[0]}')\n f = get_subfolder(f, f'{self}')\n f = get_subfolder(f, 'generations')\n \n # Save the population\n store_pickle(self, f'{f}gen_{self.generation:05d}')\n self.log(f\"Population '{self}' saved! Current generation: {self.generation}\")","def setMaterial(self,massFraction,polymer):\n M = Materials()\n num = self.material['Detector']['mt']\n if polymer == 'PS':\n self.material['Detector']['matString'] = M.GetPSLiF(massFraction,num)\n elif polymer == 'PEN':\n self.material['Detector']['matString'] = M.GetPENLiF(massFraction,num)\n else:\n raise ValueError('Polymer {} is not in the material database'.format(polymer))","def update_makes_file(target_make=None):\n persisted_makes = load_make_models_json()\n persisted_makes_by_slug = {make[\"make_slug\"]: make for make in persisted_makes}\n\n all_makes = fetch_all_makes()\n for make in tqdm(all_makes):\n if make[\"make_name\"] == \"FISKER AUTOMOTIVE\":\n # This is a dumb name that doesn't match canada's name.\n make[\"make_name\"] = \"Fisker\"\n make[\"make_slug\"] = \"fisker\"\n if make[\"make_id\"] == 1033:\n # Skip the generic \"FISKER\" make, which lists no cars for some reason.\n continue\n if target_make and target_make != make[\"make_slug\"]:\n continue\n\n if make_is_whitelisted(make, warn_if_unlisted=True):\n persisted_makes_by_slug[make[\"make_slug\"]] = make\n print(f\"{make['make_name']} produces passenger vehicles: {make}\")\n else:\n continue\n\n if not make_produces_passenger_vehicles(make[\"make_id\"]):\n # There are too many random car brands, so we focus on just those makings cars and/or trucks\n continue\n\n makes_and_models = list(sorted(persisted_makes_by_slug.values(), key=lambda make: make[\"make_slug\"]))\n persist_json_file(makes_and_models, \"data\", \"makes_and_models.json\")","def saveObjectMaps(self):\n if self.objectMaps == None: return\n path = os.path.join(self.dir,settings['mosh.modInfos.objectMaps'])\n outDir = os.path.split(path)[0]\n if not os.path.exists(outDir): os.makedirs(outDir)\n cPickle.dump(self.objectMaps,open(path,'wb'),2)","def save(self):\n\n\t\tdirectory = os.path.dirname(self.path)\n\n\t\tif not os.path.exists(directory):\n\t\t\tos.makedirs(directory)\n\n\t\twith open(self.path, \"w\") as f:\n\t\t\tf.write(\n\t\t\t\tjson.dumps(\n\t\t\t\t\tself.dump(),\n\t\t\t\t\tindent=4,\n\t\t\t\t\tsort_keys=True\n\t\t\t\t)\n\t\t\t)","def save(self, json_path):\n with open(json_path, 'w') as f:\n json.dump(self.__dict__, f, indent=4)","def save(self, json_path):\n with open(json_path, 'w') as f:\n json.dump(self.__dict__, f, indent=4)","def save(self, json_path):\n with open(json_path, 'w') as f:\n json.dump(self.__dict__, f, indent=4)","def save(self):\n\n with open(FileStorage.__file_path, \"w\") as file:\n dictionary = {}\n for a, b in FileStorage.__objects.items():\n dictionary[a] = b.to_dict()\n ink = json.dumps(dictionary)\n file.write(ink)","def saver(filename = None):\n save(self, filename)","def save(self, filename, path=None):\n import os\n\n if path is None:\n from art import DATA_PATH\n full_path = os.path.join(DATA_PATH, filename)\n else:\n full_path = os.path.join(path, filename)\n folder = os.path.split(full_path)[0]\n if not os.path.exists(folder):\n os.makedirs(folder)\n\n self._model.save(str(full_path))\n logger.info('Model saved in path: %s.', full_path)","def save(self, filename):\n data = {\"sizes\": self.sizes,\n \"weights\": [w.tolist() for w in self.weights],\n \"biases\": [b.tolist() for b in self.biases]}\n f = open(filename, \"w\")\n json.dump(data, f)\n f.close()","def save(self, filename='mesh.json', verbose=False):\n\n f = os.path.abspath(filename) # make sure we are working with abs path\n with open(f, 'w') as outfile:\n json.dump(self.serialize(), outfile)\n\n if verbose is True:\n print('Saved {}'.format(f))\n\n return f","def savemat(self, file_name):\n d = {'dG0_prime': self.dG0_prime,\n 'dG0': self.dG0,\n 'T': self.T,\n 'I': self.I,\n 'pH': self.pH,\n 'pMg': self.pMg,\n 'weight': self.weight,\n 'cids': self.cids,\n 'S': self.S.values}\n savemat(file_name, d, oned_as='row')","def saveSettings(self):\n helpers.saveFile(self.dataDir, self.settingsFilename, json.dumps(self.settings))","def save(self, projectData, filename):\n f = open(filename, 'wb')\n pickle.dump(projectData, f, protocol=1)\n f.close()","def save(self, uri):\r\n pf = PyFolder(os.path.dirname(os.path.realpath(uri)), allow_override=True)\r\n pf[os.path.basename(uri)+\"_options.json\"] = {\r\n 'input_cells': self._input_cells,\r\n 'latent_space': self._latent_space,\r\n }\r\n\r\n save_model(self._autoencoder, uri+\"_lstm_autoencoder.hdf5\")\r\n save_model(self._encoder, uri+\"_lstm_encoder.hdf5\")","def save(self):\n\n toStore = {\n key: obj.to_dict()\n for key, obj in FileStorage.__objects.items()\n }\n with open(FileStorage.__file_path, 'wt') as file:\n json.dump(toStore, file)","def store(self, file=None):\n params = self.info()\n if not file:\n folder = os.path.dirname(self.file)\n assert os.path.isdir(folder)\n file = os.path.join(folder, self.generate_name() + \".json\")\n assert os.path.splitext(file)[1] == \".json\"\n self.file = file\n self.tf_checkpoint_path = os.path.splitext(file)[0]\n if os.path.isfile(file):\n print(\"Overwriting '{}' ...\".format(self.tf_checkpoint_path))\n else:\n print(\"Creating '{}' ...\".format(self.tf_checkpoint_path))\n with open(file, 'w') as open_file:\n json.dump(params, open_file, indent=2, sort_keys=True)","def save(self):\n data = \"\"\n for y in xrange(0, BLOCK_NUM_HEIGHT):\n for x in xrange(0, BLOCK_NUM_WIDTH):\n data += self.blocks[y][x]\n data += '\\n'\n print data\n options = {'defaultextension': '.lvl',\n 'filetypes': [('Levels', '.lvl'), ('All files', '*')],\n 'initialdir': 'levels',\n 'initialfile': '',\n 'title': 'Save level'}\n # filename = tkFileDialog.asksaveasfile(**options)\n filename = asksaveasfilename(**options)\n if filename:\n with open(filename, \"w\") as level:\n level.write(data)","def save(self, filename=\"matpipe.p\"):\n temp_backend = self.learner.backend\n self.learner._backend = self.learner.backend.fitted_pipeline_\n for obj in [self, self.learner, self.reducer, self.cleaner,\n self.autofeaturizer]:\n obj._logger = None\n with open(filename, 'wb') as f:\n pickle.dump(self, f)\n self.learner._backend = temp_backend","def _write(self, preset_type, data):\n logger.debug('write presets for %s', self._device.name)\n with self._file_open_rlock(preset_type) as f:\n f.seek(0)\n yaml.dump(data, f, default_flow_style=False)\n f.truncate()","def save(self, file=\"setup\", path=\"settings\"):\n\n # check if filename already contains file extension, if not, add it\n if file[-5:] != '.json':\n file += '.json'\n # save mappings data to file\n with open(os.path.join(path, file), 'w') as file:\n json.dump(self.data, file)","def save(self):\n # Ensure store path exists\n store_path = self.manager.store_path\n if not os.path.exists(store_path):\n os.makedirs(store_path)\n \n # Get filepath\n filename = self._filename\n \n # Write into file\n raw = self.to_json()\n self.service.log.store('Saving %s' % filename)\n f = open(filename, 'w')\n f.write(raw)\n f.close()","def save_training(self):\n\n filename = str(hashlib.sha1(str(self.training_data).encode(\"utf-8\"))\n .hexdigest())\n path = \"./training/\" + filename + \".json\"\n\n data = {\n \"states\": self.states,\n \"transitions\": self.transitions,\n \"matrix\": self.matrix.tolist()\n }\n\n with open(path, \"w\") as outfile:\n json.dump(data, outfile)","def save_root(self, filename=None):\n if not filename:\n filename = tkFileDialog.asksaveasfilename()\n if filename:\n maketree.populate(self.initial.itervalues(),\n self.detectors.itervalues())\n maketree.write(filename)","def save_as_mat(data, name=\"model\"):\n import scipy.io as sio\n\n # sio.savemat(name'.mat',{name:b})\n sio.savemat(name + \".mat\", {name: data})","def save(self):\n if PYTHON3:\n fileobj = open(self.filename, 'w', encoding=self.ENCODING, errors=\"replace\")\n else:\n fileobj = open(self.filename, 'w')\n self.save_to_fileobj(fileobj)\n fileobj.close()","def save(self, dir_name=None):\n root_dir = os.getcwd()\n cur_datetime = str(datetime.datetime.now()).split(\".\")[0] # remove fractional seconds\n if not dir_name:\n dir_name = \"game_\" + cur_datetime + \"/\"\n save_dir = root_dir + \"/saved_games/\" + dir_name + \"_\" + cur_datetime + \"/\"\n\n # Check if the filepath already exists\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n\n # Game\n game_dir = save_dir + \"game/\"\n os.makedirs(game_dir)\n with open(game_dir + \"game.json\", \"w\") as file_handle:\n game_dict = self.to_json_dict()\n json.dump(game_dict, file_handle)\n\n # Player\n player_dir = save_dir + \"player/\"\n os.makedirs(player_dir)\n with open(player_dir + \"player.json\", \"w\") as file_handle:\n player_dict = self.player.to_json_dict()\n json.dump(player_dict, file_handle)\n\n # Items\n items_dir = save_dir + \"items/\"\n os.makedirs(items_dir)\n for i in self.items:\n with open(items_dir + i.get_name() + \"_\" + str(i.get_id()) + \".json\", \"w\") as file_handle:\n item_dict = i.to_json_dict()\n json.dump(item_dict, file_handle)\n\n # Characters\n characters_dir = save_dir + \"characters/\"\n os.makedirs(characters_dir)\n for c in self.characters:\n with open(characters_dir + c.get_name() + \"_\" + str(c.get_id()) + \".json\", \"w\") as file_handle:\n character_dict = c.to_json_dict()\n json.dump(character_dict, file_handle)\n\n # Spaces\n spaces_dir = save_dir + \"spaces/\"\n os.makedirs(spaces_dir)\n for s in self.spaces:\n with open(spaces_dir + s.get_name() + \"_\" + str(s.get_id()) + \".json\", \"w\") as file_handle:\n spaces_dict = s.to_json_dict()\n json.dump(spaces_dict, file_handle)\n\n # Exits\n exits_dir = save_dir + \"exits/\"\n os.makedirs(exits_dir)\n for e in self.exits:\n with open(exits_dir + e.get_name() + \"_\" + str(e.get_id()) + \".json\", \"w\") as file_handle:\n exits_dict = e.to_json_dict()\n json.dump(exits_dict, file_handle)","def save(self):\n self.lock.acquire()\n try:\n self.xml.set(\"name\",self.name)\n self.xml.set(\"room\",self.room)\n self.xml.set(\"type\",self.type)\n self.xml.find(\"address\").text = \":\".join([str(x) for x in self.address])\n if self.pos is not None:\n self.xml.find(\"pos\").text = \" \".join([str(x) for x in self.pos])\n self.xml.find(\"icon\").text = self.icon\n \n finally:\n self.lock.release()\n \n self.house.save_devices()","def save(self, path):\n if path.endswith(\".gz\"):\n file = gzip.open(path, \"w\", 9)\n else:\n file = open(path, \"wb\")\n\n # update the settings in the data to the latest value\n data = json.loads(self.value)\n data[\"settings\"] = self.settings\n\n file.write(json.dumps(data).encode(\"utf8\"))\n file.close()"],"string":"[\n \"def save_material(filename, mat):\\n out = np.array([mat.wav, mat.eps.real, mat.eps.imag,\\n mat.mu.real, mat.mu.imag]).T\\n header = \\\"Wavelength\\\\teps_real\\\\teps_imag\\\\tmu_real\\\\tmu_imag\\\"\\n miepy.array_io.save(filename, out, header=header)\",\n \"def WriteStructuralMaterialsjson(save_path,dic_in_json_format):\\n complete_name=os.path.join(save_path,\\\"StructuralMaterials.json\\\") \\n with open(complete_name, \\\"w\\\") as save_file:\\n save_file.write(dic_in_json_format)\\n if(DEBUG):\\n print(\\\"StructuralMaterials.json written\\\")\",\n \"def save_and_reload_scene():\\n\\n flg = logging.getLogger(\\\"lettuce.xgenSetup.save_and_reload_scene\\\")\\n\\n current_file = mc.file(save=True)\\n flg.info(\\\"Current File: {}\\\".format(current_file))\\n mc.file(current_file, ignoreVersion=True, open=True, force=True)\",\n \"def export_material(self, bo, bm):\\n\\n # Sometimes, a material might need to be single-use. Right now, the most apparent example\\n # of that situation is when a lightmap image is baked. Wavesets are in the same boat, but\\n # that's a special case as of the writing of this code.\\n single_user = self._requires_single_user_material(bo, bm)\\n if single_user:\\n mat_name = \\\"{}_AutoSingle\\\".format(bm.name) if bo.name == bm.name else \\\"{}_{}\\\".format(bo.name, bm.name)\\n self._report.msg(\\\"Exporting Material '{}' as single user '{}'\\\", bm.name, mat_name, indent=1)\\n hgmat = None\\n else:\\n mat_name = bm.name\\n self._report.msg(\\\"Exporting Material '{}'\\\", mat_name, indent=1)\\n hsgmat = self._mgr.find_key(hsGMaterial, name=mat_name, bl=bo)\\n if hsgmat is not None:\\n return hsgmat\\n\\n hsgmat = self._mgr.add_object(hsGMaterial, name=mat_name, bl=bo)\\n slots = [(idx, slot) for idx, slot in enumerate(bm.texture_slots) if self._can_export_texslot(slot)]\\n\\n # There is a major difference in how Blender and Plasma handle stencils.\\n # In Blender, the stencil is on top and applies to every layer below is. In Plasma, the stencil\\n # is below the SINGLE layer it affects. The main texture is marked BindNext and RestartPassHere.\\n # The pipeline indicates that we can render 8 layers simultaneously, so we will collect all\\n # stencils and apply this arrangement. We're going to limit to 6 stencils however. 1 layer for\\n # main texture and 1 piggyback.\\n num_stencils = sum((1 for i in slots if i[1].use_stencil))\\n if num_stencils > _MAX_STENCILS:\\n raise ExportError(\\\"Material '{}' uses too many stencils. The maximum is {}\\\".format(bm.name, _MAX_STENCILS))\\n stencils = []\\n restart_pass_next = False\\n\\n # Loop over layers\\n for idx, slot in slots:\\n # Prepend any BumpMapping magic layers\\n if slot.use_map_normal:\\n if bo in self._bump_mats:\\n raise ExportError(\\\"Material '{}' has more than one bumpmap layer\\\".format(bm.name))\\n du, dw, dv = self.export_bumpmap_slot(bo, bm, hsgmat, slot, idx)\\n hsgmat.addLayer(du.key) # Du\\n hsgmat.addLayer(dw.key) # Dw\\n hsgmat.addLayer(dv.key) # Dv\\n\\n if slot.use_stencil:\\n stencils.append((idx, slot))\\n else:\\n tex_layer = self.export_texture_slot(bo, bm, hsgmat, slot, idx)\\n if restart_pass_next:\\n tex_layer.state.miscFlags |= hsGMatState.kMiscRestartPassHere\\n restart_pass_next = False\\n hsgmat.addLayer(tex_layer.key)\\n if slot.use_map_normal:\\n self._bump_mats[bo] = (tex_layer.UVWSrc, tex_layer.transform)\\n # After a bumpmap layer(s), the next layer *must* be in a\\n # new pass, otherwise it gets added in non-intuitive ways\\n restart_pass_next = True\\n if stencils:\\n tex_state = tex_layer.state\\n if not tex_state.blendFlags & hsGMatState.kBlendMask:\\n tex_state.blendFlags |= hsGMatState.kBlendAlpha\\n tex_state.miscFlags |= hsGMatState.kMiscRestartPassHere | hsGMatState.kMiscBindNext\\n curr_stencils = len(stencils)\\n for i in range(curr_stencils):\\n stencil_idx, stencil = stencils[i]\\n stencil_name = \\\"STENCILGEN_{}@{}_{}\\\".format(stencil.name, bm.name, slot.name)\\n stencil_layer = self.export_texture_slot(bo, bm, hsgmat, stencil, stencil_idx, name=stencil_name)\\n if i+1 < curr_stencils:\\n stencil_layer.state.miscFlags |= hsGMatState.kMiscBindNext\\n hsgmat.addLayer(stencil_layer.key)\\n\\n # Plasma makes several assumptions that every hsGMaterial has at least one layer. If this\\n # material had no Textures, we will need to initialize a default layer\\n if not hsgmat.layers:\\n layer = self._mgr.find_create_object(plLayer, name=\\\"{}_AutoLayer\\\".format(bm.name), bl=bo)\\n self._propagate_material_settings(bm, layer)\\n hsgmat.addLayer(layer.key)\\n\\n # Cache this material for later\\n mat_list = self._obj2mat.setdefault(bo, [])\\n mat_list.append(hsgmat.key)\\n\\n # Looks like we're done...\\n return hsgmat.key\",\n \"def saveCallback(self):\\n\\n ## TODO // TEST IT\\n self._pathsDict[\\\"sceneFile\\\"] = self.getSceneFile()\\n try:\\n openSceneInfo = self.getOpenSceneInfo()\\n if not openSceneInfo:\\n return\\n except TypeError:\\n return\\n if openSceneInfo[\\\"jsonFile\\\"]:\\n jsonInfo = self._loadJson(openSceneInfo[\\\"jsonFile\\\"])\\n if jsonInfo[\\\"ReferenceFile\\\"]:\\n absRefFile = os.path.join(self._pathsDict[\\\"projectDir\\\"], jsonInfo[\\\"ReferenceFile\\\"])\\n # TODO : ref => Dict\\n absBaseSceneVersion = os.path.join(self._pathsDict[\\\"projectDir\\\"], jsonInfo[\\\"Versions\\\"][int(jsonInfo[\\\"ReferencedVersion\\\"]) - 1][\\\"RelativePath\\\"])\\n # if the refererenced scene file is the saved file (saved or saved as)\\n if self._pathsDict[\\\"sceneFile\\\"] == absBaseSceneVersion:\\n # copy over the forReference file\\n try:\\n shutil.copyfile(self._pathsDict[\\\"sceneFile\\\"], absRefFile)\\n print \\\"Scene Manager Update:\\\\nReference File Updated\\\"\\n except:\\n pass\",\n \"def menu_save_scene(self):\\n file_name = QtGui.QFileDialog().getSaveFileName(self, \\\"Save Scene to File\\\", get_data_path(), \\\"*.pkl\\\")\\n with open(file_name, \\\"wb\\\") as f:\\n pickle.dump(self.scene, f, pickle.HIGHEST_PROTOCOL)\",\n \"def save(self, filename=None):\\n if filename is None:\\n filename = \\\"morse_smale_complex.json\\\"\\n with open(filename, \\\"w\\\") as fp:\\n fp.write(self.to_json())\",\n \"def savemat(self, file_name, mdict=None, appendmat=True, **kwargs):\\n # Set mdict default value to empty dictionary\\n if mdict is None:\\n mdict = {}\\n\\n # Merge mdict with attributes dictionary, giving mdict the upper-hand\\n # in case of inconsistency\\n dsavemat = {**vars(self), **mdict}\\n\\n # Save the merged dictionary to a .mat file\\n scipy.io.savemat(file_name, dsavemat, appendmat, **kwargs)\",\n \"def AssembleStructuralMaterialsJson(KratosWindowManager):\\n for key in KratosWindowManager.MatSave.keys():\\n if(DEBUG):\\n print(key)\\n print(type(KratosWindowManager.MatSave[key]))\\n sm.structuralmaterials_dict[\\\"properties\\\"][0][\\\"Material\\\"][\\\"Variables\\\"][key]=KratosWindowManager.MatSave[key]\\n for bclistobject in KratosWindowManager.boundaryConditionEditor:\\n if(DEBUG):\\n print(bclistobject.name)\\n if bclistobject.entityType=='Element':\\n sm.structuralmaterials_dict[\\\"properties\\\"][0][\\\"model_part_name\\\"]=bclistobject.name\\n\\n\\n if KratosWindowManager.is2D:\\n sm.structuralmaterials_dict[\\\"properties\\\"][0][\\\"Material\\\"][\\\"constitutive_law\\\"][\\\"name\\\"]=\\\"KratosMultiphysics.StructuralMechanicsApplication.LinearElasticPlaneStrain2DLaw\\\"\\n else:\\n sm.structuralmaterials_dict[\\\"properties\\\"][0][\\\"Material\\\"][\\\"constitutive_law\\\"][\\\"name\\\"]=\\\"KratosMultiphysics.StructuralMechanicsApplication.LinearElastic3DLaw\\\"\\n \\n\\n if(DEBUG):\\n print(sm.structuralmaterials_dict)\\n return sm.WriteMaterialToJson(sm.structuralmaterials_dict)\",\n \"def test_save_materials(temp_dir):\\n image1 = [[[0, 0, 0], [0, 0, 0]], [[255, 255, 255], [255, 255, 255]]]\\n image2 = [[[0, 0, 0], [255, 255, 255]], [[255, 255, 255], [0, 0, 0]]]\\n image3 = [[[255, 255, 255], [255, 255, 255]], [[0, 0, 0], [0, 0, 0]]]\\n\\n data = [\\n (\\\"image1.png\\\", Image.fromarray(np.array(image1, dtype=np.uint8))),\\n (\\\"image2.png\\\", Image.fromarray(np.array(image2, dtype=np.uint8))),\\n (\\\"image3.png\\\", Image.fromarray(np.array(image3, dtype=np.uint8))),\\n ]\\n save_materials(temp_dir, data, step=1)\\n\\n assert os.path.exists(os.path.join(temp_dir, \\\"images\\\", \\\"1\\\", \\\"image1.png\\\"))\\n assert os.path.exists(os.path.join(temp_dir, \\\"images\\\", \\\"1\\\", \\\"image2.png\\\"))\\n assert os.path.exists(os.path.join(temp_dir, \\\"images\\\", \\\"1\\\", \\\"image3.png\\\"))\",\n \"def read_material_data(self, material):\\n material_yaml_file = glob.glob(os.path.join(material_dir, material + '.yaml'))\\n\\n inputs = utilities.yaml_reader(material_yaml_file, material_dir, material)\\n self.name = inputs['Name']\\n self.materialName = material\\n self.elements = inputs['Elements']\\n self.zaids = inputs['Elemental ZAIDs']\\n self.weightFraction = inputs['Elemental Weight Fractions'] if 'Elemental Weight Fractions' in inputs else []\\n self.enrichmentZaids = inputs['Elemental Adjustment ZAIDs'] if 'Elemental Adjustment ZAIDs' in inputs else []\\n self.enrichmentIsotopes = inputs['Isotopic Adjustment ZAIDs'] if 'Isotopic Adjustment ZAIDs' in inputs else []\\n self.enrichmentVector = inputs['Isotopic Weight Percents'] if 'Isotopic Weight Percents' in inputs else []\\n self.isotopicAtomPercents = inputs['Isotopic Atom Percents'] if 'Isotopic Atom Percents' in inputs else []\\n self.density = inputs['Density']\\n self.linearCoeffExpansion = inputs['Linear Coefficient of Expansion']\",\n \"def save_meta(self):\\n # jOut = os.path.join(self.meta[\\\"wdir\\\"], meta_file)\\n with open(self.meta_filepath, \\\"w\\\") as f:\\n json.dump(self.meta, f)\",\n \"def write_savefile(state: PhysicsState, file: Path):\\n if file.suffix.lower() != '.json':\\n # Ensure a .json suffix.\\n file = file.parent / (file.name + '.json')\\n log.info(f'Saving to savefile {file.resolve()}')\\n\\n savefile_json_dict = google.protobuf.json_format.MessageToDict(\\n state.as_proto(),\\n including_default_value_fields=False,\\n preserving_proto_field_name=True,\\n use_integers_for_enums=False,\\n )\\n\\n for i, component in enumerate(savefile_json_dict['engineering']['components']):\\n component['name'] = strings.COMPONENT_NAMES[i]\\n\\n with open(file, 'w') as outfile:\\n json.dump(savefile_json_dict, outfile, indent=2)\\n\\n return file\",\n \"def set_material(properties,object,finish,normal):\\n if object not in properties:\\n properties[object.getName()]={}\\n properties[object.getName()][\\\"finish\\\"]=finish\\n properties[object.getName()][\\\"normal\\\"]=normal\",\n \"def write_saver_defs(self):\\n assert self.savers_constructed\\n full_saver_def = self.full_saver.as_saver_def()\\n full_file = self.params.save_dir+self.params.model_name+\\\"_v\\\"+self.params.version+\\\".def\\\"\\n with open(full_file, \\\"wb\\\") as f:\\n f.write(full_saver_def.SerializeToString())\\n self.logger.log_info(\\\"Full saver def saved in file %s\\\"%full_file)\",\n \"def save(self):\\n for name, param in self.components.items():\\n param_path = os.path.join(self.model_path, \\\"%s.mat\\\" % name)\\n if hasattr(param, 'params'):\\n param_values = {p.name: p.get_value() for p in param.params}\\n else:\\n param_values = {name: param.get_value()}\\n scipy.io.savemat(param_path, param_values)\",\n \"def write_mat_file(self):\\n mat_dict = {}\\n mat_dict['Lx_p'] = self.Lx_p\\n mat_dict['Ly_p'] = self.Ly_p\\n mat_dict['Lz_p'] = self.Lz_p\\n mat_dict['Lo'] = self.obst.get_Lo()\\n mat_dict['Ny_divs'] = self.N_divs\\n mat_dict['rho_p'] = self.rho_p\\n mat_dict['nu_p'] = self.nu_p\\n mat_dict['snl'] = list(np.union1d(self.obst_list[:],self.solid_list[:]))\\n mat_dict['inl'] = list(self.inlet_list[:])\\n mat_dict['onl'] = list(self.outlet_list[:])\\n\\n scipy.io.savemat('geometry_description',mat_dict)\",\n \"def make_settings():\\n settings = {}\\n num_of_rocks = 1\\n\\n obj = json.load(open('assets/add_mesh_rocks.json'))\\n presets = [obj[\\\"settings\\\"][\\\"default\\\"]] + obj[\\\"settings\\\"][\\\"preset\\\"]\\n\\n for preset in presets:\\n title = preset[\\\"title\\\"]\\n # SIZE\\n size = preset[\\\"size\\\"]\\n\\n x, y, z = size[\\\"scale\\\"]\\n if title == \\\"Default\\\":\\n scale = uniform(float(x[\\\"lower\\\"]), float(x[\\\"upper\\\"]))\\n scale_X = [scale, scale]\\n scale_Y = [scale, scale]\\n scale_Z = [scale, scale]\\n else:\\n scale_X = [float(x[\\\"lower\\\"]), float(x[\\\"upper\\\"])]\\n scale_Y = [float(y[\\\"lower\\\"]), float(y[\\\"upper\\\"])]\\n scale_Z = [float(z[\\\"lower\\\"]), float(z[\\\"upper\\\"])]\\n\\n x, y, z = size[\\\"skew\\\"]\\n skew_X = float(x[\\\"value\\\"])\\n skew_Y = float(y[\\\"value\\\"])\\n skew_Z = float(z[\\\"value\\\"])\\n\\n scale_fac = ast.literal_eval(size[\\\"scale_fac\\\"])\\n use_scale_dis = bool(size[\\\"use_scale_dis\\\"])\\n\\n # SHAPE\\n shape = preset[\\\"shape\\\"]\\n\\n deform = float(shape[\\\"deform\\\"])\\n rough = float(shape[\\\"rough\\\"])\\n detail = float(shape[\\\"detail\\\"])\\n display_detail = float(shape[\\\"display_detail\\\"])\\n smooth_fac = float(shape[\\\"smooth_fac\\\"])\\n smooth_it = float(shape[\\\"smooth_it\\\"])\\n\\n\\n # MATERIAL\\n material = preset[\\\"material\\\"]\\n \\n mat_enable = bool(material[\\\"mat_enable\\\"])\\n mat_color = ast.literal_eval(material[\\\"mat_color\\\"])\\n mat_bright = float(material[\\\"mat_bright\\\"])\\n mat_rough = float(material[\\\"mat_rough\\\"])\\n mat_spec = float(material[\\\"mat_spec\\\"])\\n mat_hard = float(material[\\\"mat_hard\\\"])\\n mat_use_trans = bool(material[\\\"mat_use_trans\\\"])\\n mat_alpha = float(material[\\\"mat_alpha\\\"])\\n mat_cloudy = float(material[\\\"mat_cloudy\\\"])\\n mat_IOR = float(material[\\\"mat_IOR\\\"])\\n mat_mossy = float(material[\\\"mat_mossy\\\"])\\n\\n # RANDOM\\n random = preset[\\\"random\\\"]\\n\\n use_generate = bool(random[\\\"use_generate\\\"])\\n use_random_seed = bool(random[\\\"use_random_seed\\\"])\\n user_seed = float(random[\\\"user_seed\\\"])\\n\\n\\n settings[title] = [\\n context,\\n scale_X,\\n skew_X,\\n scale_Y,\\n skew_Y,\\n scale_Z,\\n skew_Z,\\n scale_fac,\\n detail,\\n display_detail,\\n deform,\\n rough,\\n smooth_fac,\\n smooth_it,\\n mat_enable,\\n mat_color,\\n mat_bright,\\n mat_rough,\\n mat_spec,\\n mat_hard,\\n mat_use_trans,\\n mat_alpha,\\n mat_cloudy,\\n mat_IOR,\\n mat_mossy,\\n num_of_rocks,\\n user_seed,\\n False,\\n use_random_seed\\n ]\\n\\n return settings\",\n \"def _save(self):\\n\\n out_dict = {}\\n out_dict[\\\"version\\\"] = pyfx.__version__\\n out_dict[\\\"name\\\"] = self._name\\n out_dict[\\\"src\\\"] = self._src\\n\\n # Write out the background file as an image\\n bg_file = os.path.join(self._name,\\\"master_bg_image.png\\\")\\n pyfx.util.to_file(self._bg_frame,bg_file)\\n out_dict[\\\"bg_frame\\\"] = bg_file\\n\\n f = open(os.path.join(self._name,\\\"pyfx.json\\\"),\\\"w\\\")\\n json.dump(out_dict,f)\\n f.close()\",\n \"def append_material(self, material):\\n # First check if asset attribute exists; if not, define the asset attribute\\n if not hasattr(self, \\\"asset\\\"):\\n self.asset = ET.Element(\\\"asset\\\")\\n # If the material name is not in shared materials, add this to our assets\\n if material.name not in self.shared_materials:\\n self.asset.append(ET.Element(\\\"texture\\\", attrib=material.tex_attrib))\\n self.asset.append(ET.Element(\\\"material\\\", attrib=material.mat_attrib))\\n # Add this material name to shared materials if it should be shared\\n if material.shared:\\n self.shared_materials.add(material.name)\\n self.shared_textures.add(material.tex_attrib[\\\"name\\\"])\\n # Update prefix for assets\\n add_prefix(root=self.asset, prefix=self.naming_prefix, exclude=self.exclude_from_prefixing)\",\n \"def build_storage(self, mine, planet=None):\\n self.send_build_post(\\\"resources\\\", planet, codes.storage[mine])\",\n \"def save(self):\\n if self.loaded:\\n list_embeddingNames = [self.embeddings.vsm_name, self.synset_embeddings.vsm_name, self.imagined_embeddings.vsm_name]\\n full_file_name = self.resource_manager.get_multimodal_dataset(self.corpus, list_embeddingNames)\\n logging.info('Saving dataset to [%s]', full_file_name)\\n with lzma.open(full_file_name, 'wb') as f:\\n pickle.dump(self, f)\\n else:\\n logging.error('Dataset not loaded, call \\\"build\\\" method first!')\",\n \"def save(self):\\n memento = self.create_memento()\\n import datetime\\n f = open(str(datetime.datetime.now()).replace(' ','_')+'.saved_story','w')\\n cPickle.dump(memento,f)\\n f.close()\\n zcanvas.message(\\\"Saved!\\\")\",\n \"def save(self, path=''):\\n if not self.__isBuilt:\\n self._rebuild()\\n if not path:\\n self.w.save(self.path)\\n else:\\n if not path.endswith('.shp'):\\n path = os.path.splitext(path)[0] + '.shp'\\n self.w.save(path)\",\n \"def serialize(file):\\n global root_dir\\n global wells_list\\n global tops_list\\n global project_file\\n project_file = file\\n\\n current_project = Project(root_dir, wells_list, tops_list, file)\\n f = open(file, 'wb')\\n pickle.dump(current_project, f)\",\n \"def persist(self) -> None:\\n logger.info('Generating or Updating meta data file {}'.format(self.file_path))\\n with open(self.file_path, 'w', encoding='utf-8') as meta_file:\\n meta_file.write(json.dumps(self, default=lambda value: value.__dict__))\",\n \"def create_blender_material(self, ogremat, mat, meshId, matIdx):\\n logger.debug(\\\"create_blender_material\\\")\\n textures = ogremat.textures\\n bmat = None\\n idx = 0\\n mat_name = mat[\\\"name\\\"].split(\\\"/\\\")[0]\\n try:\\n bmat = bpy.data.materials[mat_name]\\n if bversion == 3:\\n bmat.name = \\\"tobedeleted\\\"\\n bmat = bpy.data.materials.new(mat_name)\\n except:\\n bmat = bpy.data.materials.new(mat_name)\\n self.set_uuid(bmat, ogremat.uuid)\\n # material base properties\\n if ogremat.doambient:\\n if bversion == 2:\\n bmat.setAmb(ogremat.ambient)\\n else:\\n bmat.ambient = ogremat.ambient\\n if ogremat.specular:\\n if bversion == 2:\\n bmat.setSpec(1.0)\\n bmat.setSpecCol(ogremat.specular[:3])\\n bmat.setHardness(int(ogremat.specular[3]*4.0))\\n else:\\n bmat.specular_intensity = 1.0\\n ogremat.specular[:3]\\n bmat.specular_color = ogremat.specular[:3]\\n bmat.specular_hardness = int(ogremat.specular[3]*4.0)\\n if ogremat.alpha < 1.0:\\n bmat.alpha = ogremat.alpha\\n # specular\\n for layerName, textureId in ogremat.layers.items():\\n if layerName == 'shadowMap':\\n if bversion == 2:\\n bmat.setMode(Blender.Material.Modes['SHADOWBUF'] & bmat.getMode())\\n else:\\n bmat.use_cast_buffer_shadows = True\\n if textureId:\\n textureId = textureId\\n pars = (bmat, layerName, mat[\\\"name\\\"], ogremat, idx, meshId,\\n matIdx)\\n if textureId in self._imported_assets:\\n btex = self._imported_assets[textureId]\\n self.layer_ready(btex, *pars)\\n elif self.simrt:\\n pars = (textureId,) + pars\\n if not self.Asset.downloadAsset(textureId, 0,\\n self.texture_downloaded, \\n pars,\\n main=self.doTextureDownloadTranscode):\\n self.add_texture_callback(textureId, self.layer_ready, pars[1:])\\n idx += 1\\n self._imported_materials[mat[\\\"name\\\"]] = bmat\\n return bmat\",\n \"def saveSettings(self):\\n self.genFiles.applyData()\\n self.genGraph.applyData()\",\n \"def __render_material_preview(self, scene):\\n\\n # Don't render material thumbnails.\\n (width, height) = util.get_render_resolution(scene)\\n if width <= 96:\\n return\\n\\n # Collect objects and their materials in a object -> [materials] dictionary.\\n objects_materials = {}\\n for obj in (obj for obj in scene.objects if obj.is_visible(scene) and not obj.hide_render):\\n for mat in util.get_instance_materials(obj):\\n if mat is not None:\\n if obj.name not in objects_materials.keys():\\n objects_materials[obj] = []\\n objects_materials[obj].append(mat)\\n\\n # Find objects that are likely to be the preview objects.\\n preview_objects = [o for o in objects_materials.keys() if o.name.startswith('preview')]\\n if not preview_objects:\\n return\\n\\n # Find the materials attached to the likely preview object.\\n likely_materials = objects_materials[preview_objects[0]]\\n if not likely_materials:\\n return\\n\\n # Build the path to the output preview project.\\n preview_output_dir = os.path.join(tempfile.gettempdir(), \\\"blenderseed\\\", \\\"material_preview\\\")\\n preview_project_filepath = os.path.join(preview_output_dir, \\\"material_preview.appleseed\\\")\\n\\n # Create target directories if necessary.\\n if not os.path.exists(preview_output_dir):\\n try:\\n os.makedirs(preview_output_dir)\\n except os.error:\\n self.report({\\\"ERROR\\\"}, \\\"The directory {0} could not be created. Check directory permissions.\\\".format(preview_output_dir))\\n return\\n\\n # Copy assets from template project to output directory.\\n preview_template_dir = os.path.join(os.sep.join(util.realpath(__file__).split(os.sep)[:-1]), \\\"mat_preview\\\")\\n existing_files = os.listdir(preview_output_dir)\\n for item in os.listdir(preview_template_dir):\\n if item not in existing_files:\\n copyfile(os.path.join(preview_template_dir, item), os.path.join(preview_output_dir, item))\\n\\n prev_mat = likely_materials[0]\\n prev_type = prev_mat.preview_render_type.lower()\\n\\n # Export the project.\\n writer = projectwriter.Writer()\\n file_written = writer.export_preview(scene,\\n preview_project_filepath,\\n prev_mat,\\n prev_type,\\n width,\\n height)\\n if not file_written:\\n print('Error while exporting. Check the console for details.')\\n return\\n\\n # Render the project.\\n self.__render_project_file(scene, preview_project_filepath)\",\n \"def SaveJSON(self, filename):\\n data = {\\n 'files': self._files,\\n 'ebuilds': self._ebuilds,\\n }\\n json.dump(data, open(filename, 'w'))\",\n \"def save(self, path_or_file, strict=True, fmt='auto'):\\n\\n self.validate(strict=strict)\\n\\n with _open(path_or_file, mode='w', fmt=fmt) as fdesc:\\n json.dump(self.__json__, fdesc, indent=2)\",\n \"def create_main_saver_node(self, version):\\n fps = 25\\n if version:\\n project = version.task.project\\n fps = project.fps\\n\\n random_ref_id = uuid.uuid4().hex\\n\\n output_format_data = [\\n {\\n 'name': 'jpg',\\n 'node_tree': {\\n 'type': 'Saver',\\n 'attr': {\\n 'TOOLS_Name': self.output_node_name_generator('jpg'),\\n },\\n 'input_list': {\\n 'Clip': self.output_path_generator(version, 'jpg'),\\n 'CreateDir': 1,\\n 'ProcessRed': 1,\\n 'ProcessGreen': 1,\\n 'ProcessBlue': 1,\\n 'ProcessAlpha': 0,\\n 'OutputFormat': 'JPEGFormat',\\n 'JpegFormat.Quality': 85,\\n },\\n 'connected_to': {\\n # 'ref_id': random_ref_id\\n 'Input': {\\n 'type': 'ColorCurves',\\n 'ref_id': random_ref_id,\\n 'input_list': {\\n 'EditAlpha': 0.0,\\n },\\n 'connected_to': {\\n 'Input': {\\n 'type': 'CineonLog',\\n 'input_list': {\\n 'Mode': 1,\\n # 'RedBlackLevel': 0.0,\\n # 'RedWhiteLevel': 1023.0,\\n 'RedFilmStockGamma': 1.0\\n },\\n }\\n }\\n }\\n }\\n },\\n },\\n {\\n 'name': 'tga',\\n 'node_tree': {\\n 'type': 'Saver',\\n 'attr': {\\n 'TOOLS_Name': self.output_node_name_generator('tga'),\\n },\\n 'input_list': {\\n 'Clip': self.output_path_generator(version, 'tga'),\\n 'CreateDir': 1,\\n 'ProcessRed': 1,\\n 'ProcessGreen': 1,\\n 'ProcessBlue': 1,\\n 'ProcessAlpha': 0,\\n 'OutputFormat': 'TGAFormat',\\n },\\n 'connected_to': {\\n 'ref_id': random_ref_id\\n }\\n },\\n },\\n {\\n 'name': 'exr',\\n 'node_tree': {\\n 'type': 'Saver',\\n 'attr': {\\n 'TOOLS_Name': self.output_node_name_generator('exr'),\\n },\\n 'input_list': {\\n 'Clip': self.output_path_generator(version, 'exr'),\\n 'CreateDir': 1,\\n 'ProcessRed': 1,\\n 'ProcessGreen': 1,\\n 'ProcessBlue': 1,\\n 'ProcessAlpha': 1,\\n 'OutputFormat': 'OpenEXRFormat',\\n 'OpenEXRFormat.Depth': 1, # 16-bit float\\n 'OpenEXRFormat.RedEnable': 1,\\n 'OpenEXRFormat.GreenEnable': 1,\\n 'OpenEXRFormat.BlueEnable': 1,\\n 'OpenEXRFormat.AlphaEnable': 1,\\n 'OpenEXRFormat.ZEnable': 0,\\n 'OpenEXRFormat.CovEnable': 0,\\n 'OpenEXRFormat.ObjIDEnable': 0,\\n 'OpenEXRFormat.MatIDEnable': 0,\\n 'OpenEXRFormat.UEnable': 0,\\n 'OpenEXRFormat.VEnable': 0,\\n 'OpenEXRFormat.XNormEnable': 0,\\n 'OpenEXRFormat.YNormEnable': 0,\\n 'OpenEXRFormat.ZNormEnable': 0,\\n 'OpenEXRFormat.XVelEnable': 0,\\n 'OpenEXRFormat.YVelEnable': 0,\\n 'OpenEXRFormat.XRevVelEnable': 0,\\n 'OpenEXRFormat.YRevVelEnable': 0,\\n 'OpenEXRFormat.XPosEnable': 0,\\n 'OpenEXRFormat.YPosEnable': 0,\\n 'OpenEXRFormat.ZPosEnable': 0,\\n 'OpenEXRFormat.XDispEnable': 0,\\n 'OpenEXRFormat.YDispEnable': 0,\\n },\\n 'connected_to': {\\n 'ref_id': random_ref_id\\n }\\n }\\n },\\n {\\n 'name': 'mp4',\\n 'node_tree': {\\n 'type': 'Saver',\\n 'attr': {\\n 'TOOLS_Name': self.output_node_name_generator('mp4'),\\n },\\n 'input_list': {\\n 'Clip': self.output_path_generator(version, 'mp4'),\\n 'CreateDir': 1,\\n 'ProcessRed': 1,\\n 'ProcessGreen': 1,\\n 'ProcessBlue': 1,\\n 'ProcessAlpha': 0,\\n 'OutputFormat': 'QuickTimeMovies',\\n 'ProcessMode': 'Auto',\\n 'SaveFrames': 'Full',\\n 'QuickTimeMovies.Compression': 'H.264_avc1',\\n 'QuickTimeMovies.Quality': 95.0,\\n 'QuickTimeMovies.FrameRateFps': fps,\\n 'QuickTimeMovies.KeyFrames': 5,\\n 'StartRenderScript': 'frames_at_once = comp:GetPrefs(\\\"Comp.Memory.FramesAtOnce\\\")\\\\ncomp:SetPrefs(\\\"Comp.Memory.FramesAtOnce\\\", 1)',\\n 'EndRenderScript': 'comp:SetPrefs(\\\"Comp.Memory.FramesAtOnce\\\", frames_at_once)',\\n },\\n 'connected_to': {\\n 'ref_id': random_ref_id\\n }\\n }\\n },\\n {\\n 'name': 'mov',\\n 'node_tree': {\\n 'type': 'Saver',\\n 'attr': {\\n 'TOOLS_Name': self.output_node_name_generator('mov'),\\n },\\n 'input_list': {\\n 'Clip': self.output_path_generator(version, 'mov'),\\n 'CreateDir': 1,\\n 'ProcessRed': 1,\\n 'ProcessGreen': 1,\\n 'ProcessBlue': 1,\\n 'ProcessAlpha': 0,\\n 'OutputFormat': 'QuickTimeMovies',\\n 'ProcessMode': 'Auto',\\n 'SaveFrames': 'Full',\\n 'QuickTimeMovies.Compression': 'Apple ProRes 422 HQ_apch',\\n 'QuickTimeMovies.Quality': 95.0,\\n 'QuickTimeMovies.FrameRateFps': fps,\\n 'QuickTimeMovies.KeyFrames': 5,\\n\\n 'QuickTimeMovies.LimitDataRate': 0.0,\\n 'QuickTimeMovies.DataRateK': 1000.0,\\n 'QuickTimeMovies.Advanced': 1.0,\\n 'QuickTimeMovies.Primaries': 0.0,\\n 'QuickTimeMovies.Transfer': 0.0,\\n 'QuickTimeMovies.Matrix': 0.0,\\n 'QuickTimeMovies.PixelAspectRatio': 0.0,\\n 'QuickTimeMovies.ErrorDiffusion': 1.0,\\n 'QuickTimeMovies.SaveAlphaChannel': 1.0,\\n\\n 'StartRenderScript': 'frames_at_once = comp:GetPrefs(\\\"Comp.Memory.FramesAtOnce\\\")\\\\ncomp:SetPrefs(\\\"Comp.Memory.FramesAtOnce\\\", 1)',\\n 'EndRenderScript': 'comp:SetPrefs(\\\"Comp.Memory.FramesAtOnce\\\", frames_at_once)',\\n\\n\\n\\n },\\n 'connected_to': {\\n 'ref_id': random_ref_id\\n }\\n }\\n },\\n ]\\n\\n if version.task.type and version.task.type.name == 'Plate':\\n # create a different type of outputs\\n output_format_data = [\\n {\\n 'name': 'jpg',\\n 'node_tree': {\\n 'type': 'Saver',\\n 'attr': {\\n 'TOOLS_Name': self.output_node_name_generator('jpg'),\\n },\\n 'input_list': {\\n 'Clip': self.output_path_generator(version, 'jpg'),\\n 'CreateDir': 1,\\n 'ProcessRed': 1,\\n 'ProcessGreen': 1,\\n 'ProcessBlue': 1,\\n 'ProcessAlpha': 0,\\n 'OutputFormat': 'JPEGFormat',\\n 'JpegFormat.Quality': 85,\\n },\\n },\\n },\\n {\\n 'name': 'exr',\\n 'node_tree': {\\n 'type': 'Saver',\\n 'attr': {\\n 'TOOLS_Name': self.output_node_name_generator('exr'),\\n },\\n 'input_list': {\\n 'Clip': self.output_path_generator(version, 'exr'),\\n 'CreateDir': 1,\\n 'ProcessRed': 1,\\n 'ProcessGreen': 1,\\n 'ProcessBlue': 1,\\n 'ProcessAlpha': 0,\\n 'OutputFormat': 'OpenEXRFormat',\\n 'OpenEXRFormat.Depth': 1, # 16-bit float\\n 'OpenEXRFormat.RedEnable': 1,\\n 'OpenEXRFormat.GreenEnable': 1,\\n 'OpenEXRFormat.BlueEnable': 1,\\n 'OpenEXRFormat.AlphaEnable': 0,\\n 'OpenEXRFormat.ZEnable': 0,\\n 'OpenEXRFormat.CovEnable': 0,\\n 'OpenEXRFormat.ObjIDEnable': 0,\\n 'OpenEXRFormat.MatIDEnable': 0,\\n 'OpenEXRFormat.UEnable': 0,\\n 'OpenEXRFormat.VEnable': 0,\\n 'OpenEXRFormat.XNormEnable': 0,\\n 'OpenEXRFormat.YNormEnable': 0,\\n 'OpenEXRFormat.ZNormEnable': 0,\\n 'OpenEXRFormat.XVelEnable': 0,\\n 'OpenEXRFormat.YVelEnable': 0,\\n 'OpenEXRFormat.XRevVelEnable': 0,\\n 'OpenEXRFormat.YRevVelEnable': 0,\\n 'OpenEXRFormat.XPosEnable': 0,\\n 'OpenEXRFormat.YPosEnable': 0,\\n 'OpenEXRFormat.ZPosEnable': 0,\\n 'OpenEXRFormat.XDispEnable': 0,\\n 'OpenEXRFormat.YDispEnable': 0,\\n },\\n },\\n },\\n {\\n 'name': 'mp4',\\n 'node_tree': {\\n 'type': 'Saver',\\n 'attr': {\\n 'TOOLS_Name': self.output_node_name_generator('mp4'),\\n },\\n 'input_list': {\\n 'Clip': self.output_path_generator(version, 'mp4'),\\n 'CreateDir': 1,\\n 'ProcessRed': 1,\\n 'ProcessGreen': 1,\\n 'ProcessBlue': 1,\\n 'ProcessAlpha': 0,\\n 'OutputFormat': 'QuickTimeMovies',\\n 'ProcessMode': 'Auto',\\n 'SaveFrames': 'Full',\\n 'QuickTimeMovies.Compression': 'H.264_avc1',\\n 'QuickTimeMovies.Quality': 95.0,\\n 'QuickTimeMovies.FrameRateFps': fps,\\n 'QuickTimeMovies.KeyFrames': 5,\\n 'StartRenderScript': 'frames_at_once = comp:GetPrefs(\\\"Comp.Memory.FramesAtOnce\\\")\\\\ncomp:SetPrefs(\\\"Comp.Memory.FramesAtOnce\\\", 1)',\\n 'EndRenderScript': 'comp:SetPrefs(\\\"Comp.Memory.FramesAtOnce\\\", frames_at_once)',\\n },\\n },\\n },\\n ]\\n\\n # selectively generate output format\\n saver_nodes = self.get_main_saver_node()\\n\\n for data in output_format_data:\\n format_name = data['name']\\n node_tree = data['node_tree']\\n\\n # now check if a node with the same name exists\\n format_node = None\\n format_node_name = self.output_node_name_generator(format_name)\\n for node in saver_nodes:\\n node_name = node.GetAttrs('TOOLS_Name')\\n if node_name.startswith(format_node_name):\\n format_node = node\\n break\\n\\n # create the saver node for this format if missing\\n if not format_node:\\n self.create_node_tree(node_tree)\\n else:\\n # just update the input_lists\\n if 'input_list' in node_tree:\\n input_list = node_tree['input_list']\\n for key in input_list:\\n node_input_list = format_node.GetInputList()\\n for input_entry_key in node_input_list.keys():\\n input_entry = node_input_list[input_entry_key]\\n input_id = input_entry.GetAttrs()['INPS_ID']\\n if input_id == key:\\n value = input_list[key]\\n input_entry[0] = value\\n break\\n\\n try:\\n os.makedirs(\\n os.path.dirname(\\n self.output_path_generator(version, format_name)\\n )\\n )\\n except OSError:\\n # path already exists\\n pass\",\n \"def _saveProjects(self, data):\\n logger.debug(\\\"Func: _saveProjects %s\\\")\\n\\n self._dumpJson(data, self._pathsDict[\\\"projectsFile\\\"])\",\n \"def dump_mat(filename, obj, **kwargs):\\n return sio.savemat(filename, obj, **kwargs)\",\n \"def save(self, path):\\n\\n with open(path, \\\"w\\\") as f:\\n json.dump(self.definition, f, separators=(\\\",\\\", \\\":\\\"), cls=JSONEncoder)\",\n \"def save(self, path):\\n\\n with open(path, \\\"w\\\") as f:\\n json.dump(self.definition, f, separators=(\\\",\\\", \\\":\\\"), cls=JSONEncoder)\",\n \"def save_settings(self):\\n settings = {'camera': self.comboCamera.currentIndex(),\\n 'rotation': self.comboRotation.currentIndex(),\\n 'colors': {\\n 'min_hue': self.spinMinHue.value(),\\n 'max_hue': self.spinMaxHue.value(),\\n 'min_saturation': self.spinMinSaturation.value(),\\n 'max_saturation': self.spinMaxSaturation.value(),\\n 'min_value': self.spinMinValue.value(),\\n 'max_value': self.spinMaxValue.value(),\\n }, 'diameter': self.spinDiameter.value(),\\n 'lifter': self.lineEditLifter.text(),\\n 'save_video': self.checkSaveVideo.isChecked()\\n }\\n settings_file = open('./resources/settings.json', 'w')\\n json.dump(settings, settings_file, indent=4)\\n settings_file.close()\\n self.statusbar.clearMessage()\\n self.statusbar.showMessage('Settings saved.', 5000)\",\n \"def save_(self):\\n if not self._edited:\\n return\\n data = {'history': self.dump()}\\n with open(os.path.join(os.path.dirname(self.arch_handler.dicomdir_path), self.SAVE_NAME), \\\"w\\\") as outfile:\\n json.dump(data, outfile)\\n self._edited = False\",\n \"def save(self, filepath):\\n writer = json.dump if Config.isjson(filepath) else yaml.dump\\n with open(filepath, 'w') as f:\\n writer(dict(self), f)\",\n \"def save(self):\\n if self.loaded:\\n full_file_name = self.resource_manager.get_dataset(self.corpus, self.embeddings.vsm_name)\\n logging.info('Saving dataset to [%s]', full_file_name)\\n with lzma.open(full_file_name, 'wb') as f:\\n pickle.dump(self, f)\\n else:\\n logging.error('Dataset not loaded, call \\\"build\\\" method first!')\",\n \"def save(self):\\n with open(str(self._path.resolve()), 'w+') as f:\\n json.dump(self._database, f, indent=4)\\n return self\",\n \"def AddMaterial(self, *args):\\n return _XCAFDoc.XCAFDoc_MaterialTool_AddMaterial(self, *args)\",\n \"def loadMaterial(self):\\n\\t\\tif not os.path.exists(down_dir):\\n\\t\\t\\traise TypeError(\\\"Directory 'downloads' with application materials must exist\\\")\\n\\n\\t\\tfor filename in glob.glob(down_dir + self.id+ \\\"*\\\"):\\n\\t\\t\\tdestination = self.dir + \\\"/\\\"+ filename[(len(self.id)+11)::]\\n\\t\\t\\tos.rename(filename, destination)\",\n \"def save_scene(force=True, **kwargs):\\n\\n pass\",\n \"def save(self):\\n with open(FileStorage.__file_path, 'w') as saves:\\n copy_dict = {key: self.__objects[key].to_dict()\\n for key in self.__objects}\\n json.dump(copy_dict, saves)\",\n \"def save(self):\\n a_copy = FileStorage.__objects\\n obj_dict = {obj: a_copy[obj].to_dict() for obj in a_copy.keys()}\\n with open(FileStorage.__file_path, \\\"w\\\") as f:\\n json.dump(obj_dict, f)\",\n \"def save(self, path):\\n if not is_dry():\\n with open(path, 'w') as f:\\n json.dump(self.to_dict(), f, indent=4)\\n return path\",\n \"def materials_adding_panel(self, context):\\r\\n \\r\\n AM = context.window_manager.asset_m\\r\\n layout = self.layout\\r\\n box = layout.box()\\r\\n view = context.space_data\\r\\n thumbnails_path = get_directory('icons')\\r\\n library_path = get_library_path()\\r\\n extentions = (\\\".jpg\\\", \\\".jpeg\\\", \\\".png\\\")\\r\\n thumb = [thumb.rsplit(\\\".\\\", 1)[0] for thumb in listdir(thumbnails_path) if thumb.endswith(extentions)]\\r\\n if AM.as_mat_scene:\\r\\n thumb_list = thumb + [\\\"AM_Cloth\\\", \\\"AM_Sphere\\\"]\\r\\n else: \\r\\n thumb_list = thumb\\r\\n\\r\\n cam_is_valid = False\\r\\n obj_is_valid = False\\r\\n \\r\\n \\r\\n if not AM.as_mat_scene and not bpy.context.object:\\r\\n box.prop(AM, \\\"as_mat_scene\\\", text = \\\"Save as material scene\\\")\\r\\n box.label(\\\"No active_object in the scene\\\", icon='ERROR')\\r\\n box.operator(\\\"object.cancel_panel_choise\\\", text=\\\"Cancel\\\", icon='X')\\r\\n \\r\\n elif not AM.as_mat_scene and not bpy.context.active_object.active_material:\\r\\n box.prop(AM, \\\"as_mat_scene\\\", text = \\\"Save as material scene\\\")\\r\\n box.label(\\\"The object have no material\\\", icon='ERROR')\\r\\n box.operator(\\\"object.cancel_panel_choise\\\", text=\\\"Cancel\\\", icon='X')\\r\\n \\r\\n else:\\r\\n if AM.as_mat_scene and not isdir(join(library_path, 'materials', \\\"Render Scenes\\\")):\\r\\n box.operator(\\\"object.create_rder_scn_lib\\\", text = \\\"Create render scene library\\\", icon = 'FILESEL')\\r\\n box.operator(\\\"object.cancel_panel_choise\\\", text=\\\"Cancel\\\", icon='X')\\r\\n \\r\\n else:\\r\\n \\r\\n if AM.as_mat_scene:\\r\\n asset_name = AM.scene_name\\r\\n else:\\r\\n active_mat = context.active_object.active_material\\r\\n asset_name = active_mat.name\\r\\n \\r\\n if len(bpy.context.active_object.material_slots) == 1:\\r\\n AM.multi_materials = False\\r\\n \\r\\n if AM.as_mat_scene and (not asset_name in thumb_list or asset_name in thumb_list and AM.replace_rename == 'replace') or\\\\\\r\\n not AM.as_mat_scene and (AM.multi_materials and get_valid_materials() or not AM.multi_materials and asset_name not in thumb_list or asset_name in thumb_list and AM.replace_rename == 'replace'): \\r\\n if not AM.multi_materials:\\r\\n if asset_name in thumb_list and AM.replace_rename == 'replace':\\r\\n box.label(\\\"\\\\\\\" {} \\\\\\\" already exist\\\".format(asset_name), icon='ERROR')\\r\\n box.separator()\\r\\n if len(bpy.context.active_object.material_slots) >= 2 and AM.replace_rename == 'rename':\\r\\n box.prop(AM, \\\"multi_materials\\\", text = \\\"All materials\\\")\\r\\n row = box.row(align=True)\\r\\n row.prop(AM, \\\"replace_rename\\\", text=\\\" \\\", expand=True)\\r\\n if AM.replace_rename == 'rename':\\r\\n if AM.as_mat_scene:\\r\\n box.prop(AM, \\\"scene_name\\\", text = \\\"\\\")\\r\\n else:\\r\\n box.prop(AM, \\\"rename_mat\\\", text=\\\"\\\")\\r\\n \\r\\n box.prop(AM, \\\"as_mat_scene\\\", text = \\\"Save as material scene\\\")\\r\\n if not AM.as_mat_scene and len(bpy.context.active_object.material_slots) >= 2:\\r\\n if len(get_valid_materials()) != len(bpy.context.active_object.material_slots) and AM.multi_materials:\\r\\n box.label(\\\"Some materials wont be added\\\", icon = 'ERROR')\\r\\n box.label(\\\" because there already exist\\\")\\r\\n row = box.row()\\r\\n row.prop(AM, \\\"multi_materials\\\", text = \\\"All materials\\\")\\r\\n if AM.as_mat_scene:\\r\\n row = box.row(align = True)\\r\\n row.label(\\\"Scene name:\\\")\\r\\n row.prop(AM, \\\"scene_name\\\", text = \\\"\\\")\\r\\n \\r\\n row = box.row(align = True)\\r\\n row.prop(AM, \\\"render_type\\\", text = \\\" \\\", expand = True)\\r\\n row = box.row()\\r\\n row.label(\\\"Thumbnail extention:\\\")\\r\\n row = box.row(align = True)\\r\\n row.prop(AM, \\\"thumb_ext\\\", expand = True)\\r\\n \\r\\n if AM.as_mat_scene:\\r\\n for obj in context.scene.objects:\\r\\n if obj.type == 'CAMERA':\\r\\n cam_is_valid = True\\r\\n \\r\\n if len([obj for obj in context.selected_objects if obj.type != 'CAMERA' and bpy.context.active_object == obj]) == 1:\\r\\n obj_is_valid = True\\r\\n \\r\\n row = box.row()\\r\\n row.label(\\\"Selected object rendering\\\", icon = 'FILE_TICK' if obj_is_valid else 'CANCEL')\\r\\n row = box.row()\\r\\n row.label(\\\"Camera in the scene\\\", icon = 'FILE_TICK' if cam_is_valid else 'CANCEL')\\r\\n if not cam_is_valid:\\r\\n row = box.row()\\r\\n row.operator(\\\"object.camera_add\\\", text = \\\"Add camera\\\", icon = 'OUTLINER_OB_CAMERA')\\r\\n \\r\\n if not AM.as_mat_scene:\\r\\n # --------------------- # \\r\\n # RENDER THUMBNAIL #\\r\\n # --------------------- #\\r\\n \\r\\n if AM.render_type == 'render':\\r\\n row = box.row(align = True)\\r\\n row.label(\\\"Thumbnail:\\\")\\r\\n row.prop(AM, \\\"mat_thumb_type\\\", text = \\\"\\\")\\r\\n \\r\\n # --------------------- # \\r\\n # OPENGL THUMBNAIL #\\r\\n # --------------------- #\\r\\n \\r\\n if AM.render_type == 'opengl':\\r\\n row = box.row(align=True)\\r\\n row.operator(\\\"object.setup_ogl_render\\\", text=\\\"Setup OGL render\\\" if not \\\"AM_OGL_Camera\\\" in [obj.name for obj in context.scene.objects] else \\\"View camera\\\", icon='ZOOMIN')\\r\\n row.operator(\\\"object.remove_ogl_render\\\", text=\\\"\\\", icon='ZOOMOUT')\\r\\n row = layout.column()\\r\\n row = box.row(align=True) \\r\\n row.label(\\\"Background:\\\")\\r\\n row.prop(AM, \\\"background_alpha\\\", text=\\\"\\\")\\r\\n row = box.row(align=True)\\r\\n row.prop(view, \\\"show_only_render\\\")\\r\\n\\r\\n # -------------------- # \\r\\n # IMAGE THUMBNAIL #\\r\\n # -------------------- #\\r\\n \\r\\n elif AM.render_type == 'image':\\r\\n row = box.row(align=True)\\r\\n row.prop(AM, \\\"image_type\\\", text=\\\" \\\", expand=True)\\r\\n if AM.image_type == 'disk':\\r\\n box.label(\\\"Choose your thumbnail\\\")\\r\\n box.prop(AM, \\\"custom_thumbnail_path\\\", text=\\\"\\\")\\r\\n else:\\r\\n box.prop_search(AM, \\\"render_name\\\", bpy.data, \\\"images\\\", text=\\\"\\\") \\r\\n \\r\\n row = box.row(align=True)\\r\\n if (AM.as_mat_scene and AM.scene_name and cam_is_valid and obj_is_valid or not AM.as_mat_scene) and (AM.render_type == 'render' or (asset_name not in thumb_list or AM.replace_rename == 'replace') and AM.render_type == 'opengl' or AM.render_type == 'image' and (AM.image_type == 'disk' and AM.custom_thumbnail_path or AM.image_type == 'rendered' and AM.render_name)):\\r\\n if AM.as_mat_scene:\\r\\n row.operator(\\\"object.add_scene_in_library\\\", text=\\\"OK\\\", icon='FILE_TICK')\\r\\n else:\\r\\n row.operator(\\\"object.add_material_in_library\\\", text=\\\"OK\\\", icon='FILE_TICK')\\r\\n row.operator(\\\"object.cancel_panel_choise\\\", text=\\\"Cancel\\\", icon='X')\\r\\n \\r\\n else:\\r\\n if AM.multi_materials and not get_valid_materials():\\r\\n box.label(\\\"All materials already exist\\\".format(asset_name), icon='ERROR')\\r\\n box.separator()\\r\\n if len(bpy.context.active_object.material_slots) >= 2:\\r\\n box.prop(AM, \\\"multi_materials\\\", text = \\\"All materials\\\")\\r\\n \\r\\n else:\\r\\n box.label(\\\"\\\\\\\" {} \\\\\\\" already exist\\\".format(asset_name), icon='ERROR')\\r\\n box.separator()\\r\\n if len(bpy.context.active_object.material_slots) >= 2:\\r\\n box.prop(AM, \\\"multi_materials\\\", text = \\\"All materials\\\")\\r\\n else:\\r\\n AM.multi_materials = False\\r\\n row = box.row(align=True)\\r\\n row.prop(AM, \\\"replace_rename\\\", text=\\\" \\\", expand=True)\\r\\n if AM.replace_rename == 'rename':\\r\\n if AM.as_mat_scene:\\r\\n box.prop(AM, \\\"scene_name\\\", text = \\\"\\\")\\r\\n else:\\r\\n box.prop(AM, \\\"rename_mat\\\", text=\\\"\\\")\\r\\n \\r\\n row = box.row()\\r\\n row.operator(\\\"object.cancel_panel_choise\\\", text=\\\"Cancel\\\", icon='X')\",\n \"def _save(self):\\n with open(self.file_path, 'w') as fid:\\n json.dump(self.data, fid, indent=4, sort_keys=True)\",\n \"def set_save_building(self, positions, building, pick_up_vertical, side_number):\\n current = self.get_save_buildings()\\n exist = False\\n for pos in positions:\\n print([pos[0], pos[1]])\\n\\n # Check if there is a building with the same number saved already\\n if len(current) > 0:\\n for saved_building in current:\\n print(saved_building.number)\\n if saved_building.number == building:\\n if saved_building.side_number == side_number:\\n print(\\\"[ERROR] Side already exists!\\\")\\n return\\n\\n # If it is a new building, create it and add it to the array\\n if not exist:\\n current.append(BuildingSide(positions, pick_up_vertical, building, side_number))\\n print(\\\"[INFO] Saved building\\\")\\n\\n saved_file = open(self.file_name_building, \\\"w\\\")\\n json.dump(json.dumps(current, default=lambda o: o.__dict__,\\n sort_keys=True), saved_file)\\n saved_file.close()\",\n \"def write_mat_file(self, geom_filename):\\n mat_dict = {}\\n mat_dict['Lx_p'] = self.Lx_p\\n mat_dict['Ly_p'] = self.Ly_p\\n mat_dict['Lz_p'] = self.Lz_p\\n mat_dict['Lo'] = self.obst.get_Lo()\\n mat_dict['Ny_divs'] = self.N_divs\\n mat_dict['rho_p'] = self.rho_p\\n mat_dict['nu_p'] = self.nu_p\\n mat_dict['snl'] = list(np.union1d(self.obst_list[:],self.solid_list[:]))\\n mat_dict['inl'] = list(self.inlet_list[:])\\n mat_dict['onl'] = list(self.outlet_list[:])\\n\\n scipy.io.savemat(geom_filename,mat_dict)\",\n \"def save_configurations(self):\\n # Get the file path\\n self.data_path = self.data_path_entry.get()\\n # Open the file\\n with open(self.data_path, 'rb') as file:\\n self.log('Opened ' + str(self.data_path))\\n # Un-serialize\\n info = pickle.load(file)\\n # Write the new properties\\n self.main_window.overwrite_properties(info)\\n\\n self.exit()\",\n \"def save(filename, mat):\\n if not isinstance(mat, np.ndarray):\\n raise ValueError('for now, we can only save numpy arrays')\\n return sio.savemat(filename, {'data': mat}, appendmat=False)\",\n \"def _build_writer(self):\\n # Create savers (one for current, one for best)\\n self.saver_cur = tf.train.Saver()\\n self.saver_best = tf.train.Saver()\",\n \"def save_waveform(self, chan=None):\\n t, y, pre = self.device.retrieve_current_waveform()\\n meta = self.create_meta()\\n if chan != None:\\n meta['Channel'] = chan\\n for name in pre:\\n meta[name] = pre[name]\\n data = {'meta' : meta,\\n 't' : t,\\n 'y' : y}\\n rsp = daq.Rsp('save', data, meta)\\n self.shot += 1\\n self.r_queue.put(rsp)\",\n \"def write_material_data(ka_red=255.0 / 255, ka_green=255.0 / 255, ka_blue=255.0 / 255,\\n ka_texture_ID=9223372036854775807, # ambient\\n ks_red=255.0 / 255, ks_green=255.0 / 255, ks_blue=255.0 / 255,\\n ks_texture_ID=9223372036854775807, # specular\\n kd_red=255.0 / 255, kd_green=255.0 / 255, kd_blue=255.0 / 255,\\n kd_texture_ID=9223372036854775807, # diffuse\\n ns=0.1, # specular exponent\\n alpha=1 # opacity\\n ):\\n\\n input_ = [(ka_red, 'float32'), (ka_green, 'float32'), (ka_blue, 'float32'),\\n (ka_texture_ID, 'uint64'),\\n (ks_red, 'float32'), (ks_green, 'float32'), (ks_blue, 'float32'),\\n (ks_texture_ID, 'uint64'),\\n (kd_red, 'float32'), (kd_green, 'float32'), (kd_blue, 'float32'),\\n (kd_texture_ID, 'uint64'),\\n (ns, 'float32'), (alpha, 'float32')]\\n\\n block_bytes = encode(input_)\\n return block_bytes\",\n \"def build_saver(self):\\n #this is used to restore and save the graph default_saver.restore\\n\\n default_saver = tf.train.Saver(max_to_keep=3, allow_empty=True)\\n self.savers = {self.name: default_saver}\",\n \"def create_material_data(self):\\n for num, zaid in enumerate(self.enrichmentZaids):\\n enriched_isotope_dict = {}\\n for isoNum, isotopes in enumerate(self.enrichmentIsotopes[num]):\\n enriched_isotope_dict[isotopes] = self.enrichmentVector[num][isoNum]\\n self.enrichmentDict[zaid] = enriched_isotope_dict\\n for num, element in enumerate(self.elements):\\n self.elementDict[self.zaids[num]] = Element.Element(element)\\n\\n if self.isotopicAtomPercents:\\n self.atomDensity = self.density\\n self.set_atom_fractions()\\n else:\\n self.set_elemental_enrichment()\\n self.set_weight_percent()\\n self.atomDensity, self.atomPercent = set_atom_percent(self.weightPercent, self.density,\\n self.elementDict)\",\n \"def save(self, settings=None):\\n json_string = json.dumps(self.variables)\\n with open(self.filepath, 'w', encoding='utf-8') as fh:\\n fh.write(json_string)\",\n \"def save_game(partie):\\n fichier= open(\\\"save_game.json\\\",\\\"w\\\")\\n json.dump(partie,fichier)\\n fichier.close()\",\n \"def get_save_buildings(self):\\n saved_building = []\\n print(\\\"Get saved buildings\\\")\\n try:\\n saved_file = open(self.file_name_building)\\n try:\\n data = json.loads(json.load(saved_file))\\n for p in data:\\n saved_building.append(\\n BuildingSide(p.get(\\\"side\\\"), p.get(\\\"pick_up_vertical\\\"), p.get(\\\"number\\\"), p.get(\\\"side_number\\\")))\\n\\n except json.decoder.JSONDecodeError:\\n saved_building = []\\n\\n saved_file.close()\\n except FileNotFoundError:\\n saved_building = []\\n\\n return saved_building\",\n \"def save(self):\\n with open(self.file_path, 'w', encoding=Config.ENCODING) as file:\\n json.dump(self.data, file, indent=2, ensure_ascii=False)\",\n \"def save(self):\\r\\n os.makedirs(self.settings.save_path, exist_ok=True)\\r\\n current_file = os.path.join(self.settings.save_path, 'current.json')\\r\\n if os.path.exists(current_file):\\r\\n raise FileExistsError()\\r\\n current_folder = os.path.join(self.settings.save_path, 'current')\\r\\n os.makedirs(current_folder, exist_ok=True)\\r\\n\\r\\n tosave = {\\r\\n 'generation': self.generation,\\r\\n 'approach_ind': self.approach[0],\\r\\n 'approach_params': Evolver._clean_params(self.approach_params),\\r\\n 'sensitive_params': Evolver._clean_params(self.sensitive_params)\\r\\n }\\r\\n\\r\\n with open(current_file, 'w') as outfile:\\r\\n json.dump(tosave, outfile)\",\n \"def generate_file(material_id):\\n apr=get_doc_from_MP(material_id)\\n mat_list=generate_matrix(apr)\\n formu=POSCAR_title(apr)\\n cell_for=generate_cell_formula(apr)\\n needed_dos=generate_dos_str(material_id)\\n revise_dos=dos_into_string(needed_dos)\\n ordered_list=generate_ordered_list(revise_dos)\\n my_ordered_elements=generate_ordered_elements(revise_dos,ordered_list)\\n my_ordered_numbers=generate_ordered_numbers(revise_dos,ordered_list,cell_for)\\n generate_POSCAR(formu,mat_list,my_ordered_elements,my_ordered_numbers,revise_dos)\",\n \"def saveBaseScene(self, categoryName, baseName, subProjectIndex=0, makeReference=True, versionNotes=\\\"\\\", sceneFormat=\\\"nk\\\", *args, **kwargs):\\n logger.debug(\\\"Func: saveBaseScene\\\")\\n\\n now = datetime.datetime.now().strftime(\\\"%d/%m/%Y-%H:%M\\\")\\n completeNote = \\\"[%s] on %s\\\\n%s\\\\n\\\" % (self.currentUser, now, versionNotes)\\n\\n # Check if the base name is unique\\n scenesToCheck = self.scanBaseScenes(categoryAs=categoryName, subProjectAs=subProjectIndex)\\n for key in scenesToCheck.keys():\\n if baseName.lower() == key.lower():\\n msg = (\\\"Base Scene Name is not unique!\\\\nABORTING\\\")\\n self._exception(360, msg)\\n return -1, msg\\n\\n projectPath = self.projectDir\\n databaseDir = self._pathsDict[\\\"databaseDir\\\"]\\n scenesPath = self._pathsDict[\\\"scenesDir\\\"]\\n categoryPath = os.path.normpath(os.path.join(scenesPath, categoryName))\\n self._folderCheck(categoryPath)\\n\\n ## if its going to be saved as a subproject\\n if not subProjectIndex == 0:\\n subProjectPath = os.path.normpath(os.path.join(categoryPath, self._subProjectsList[subProjectIndex]))\\n self._folderCheck(subProjectPath)\\n shotPath = os.path.normpath(os.path.join(subProjectPath, baseName))\\n self._folderCheck(shotPath)\\n\\n jsonCategoryPath = os.path.normpath(os.path.join(databaseDir, categoryName))\\n self._folderCheck(jsonCategoryPath)\\n jsonCategorySubPath = os.path.normpath(os.path.join(jsonCategoryPath, self._subProjectsList[subProjectIndex]))\\n self._folderCheck(jsonCategorySubPath)\\n jsonFile = os.path.join(jsonCategorySubPath, \\\"{}.json\\\".format(baseName))\\n\\n else:\\n shotPath = os.path.normpath(os.path.join(categoryPath, baseName))\\n self._folderCheck(shotPath)\\n\\n jsonCategoryPath = os.path.normpath(os.path.join(databaseDir, categoryName))\\n self._folderCheck(jsonCategoryPath)\\n jsonFile = os.path.join(jsonCategoryPath, \\\"{}.json\\\".format(baseName))\\n\\n\\n version = 1\\n sceneName = \\\"{0}_{1}_{2}_v{3}\\\".format(baseName, categoryName, self._usersDict[self.currentUser], str(version).zfill(3))\\n sceneFile = os.path.join(shotPath, \\\"{0}.{1}\\\".format(sceneName, sceneFormat))\\n ## relativity update\\n relSceneFile = os.path.relpath(sceneFile, start=projectPath)\\n # killTurtle()\\n # TODO // cmds may be used instead\\n # pm.saveAs(sceneFile)\\n nuke.scriptSaveAs(sceneFile)\\n\\n thumbPath = self.createThumbnail(dbPath=jsonFile, versionInt=version)\\n\\n jsonInfo = {}\\n\\n if makeReference:\\n # TODO // Find an elegant solution and add MA compatibility. Can be merged with makeReference function in derived class\\n referenceName = \\\"{0}_{1}_forReference\\\".format(baseName, categoryName)\\n referenceFile = os.path.join(shotPath, \\\"{0}.{1}\\\".format(referenceName, sceneFormat))\\n ## relativity update\\n relReferenceFile = os.path.relpath(referenceFile, start=projectPath)\\n shutil.copyfile(sceneFile, referenceFile)\\n jsonInfo[\\\"ReferenceFile\\\"] = relReferenceFile\\n jsonInfo[\\\"ReferencedVersion\\\"] = version\\n else:\\n jsonInfo[\\\"ReferenceFile\\\"] = None\\n jsonInfo[\\\"ReferencedVersion\\\"] = None\\n\\n jsonInfo[\\\"ID\\\"] = \\\"SmNukeV02_sceneFile\\\"\\n jsonInfo[\\\"NukeVersion\\\"] = [nuke.NUKE_VERSION_MAJOR, nuke.NUKE_VERSION_MINOR]\\n jsonInfo[\\\"Name\\\"] = baseName\\n jsonInfo[\\\"Path\\\"] = os.path.relpath(shotPath, start=projectPath)\\n jsonInfo[\\\"Category\\\"] = categoryName\\n jsonInfo[\\\"Creator\\\"] = self.currentUser\\n jsonInfo[\\\"CreatorHost\\\"] = (socket.gethostname())\\n jsonInfo[\\\"Versions\\\"] = [ # PATH => Notes => User Initials => Machine ID => Playblast => Thumbnail\\n {\\\"RelativePath\\\": relSceneFile,\\n \\\"Note\\\": completeNote,\\n \\\"User\\\": self._usersDict[self.currentUser],\\n \\\"Workstation\\\": socket.gethostname(),\\n \\\"Preview\\\": {},\\n \\\"Thumb\\\": thumbPath,\\n \\\"Ranges\\\": self._getTimelineRanges()\\n }\\n ]\\n\\n jsonInfo[\\\"SubProject\\\"] = self._subProjectsList[subProjectIndex]\\n self._dumpJson(jsonInfo, jsonFile)\\n return [0, \\\"\\\"]\",\n \"def save(self):\\n with open(self.__file_path, \\\"w\\\", encoding=\\\"UTF-8\\\") as file:\\n parsed_dict = {\\n key: value.to_dict()\\n for key, value in self.__objects.items()\\n }\\n save_data(parsed_dict, file)\",\n \"def save(aircraft, settings):\\n\\n filepath = settings.paths('f_aircraft')\\n logger.info(f\\\"Writing aircraft model to file '{truncate_filepath(filepath)}'...\\\")\\n\\n # ====== Aircraft top level =====\\n output = {}\\n output['uid'] = aircraft.uid\\n\\n output['refs'] = {}\\n for key, value in aircraft.refs.items():\\n output['refs'][key] = value\\n\\n # ====== Wings =====\\n output['wings'] = []\\n for wing in aircraft.wings.values():\\n wing_entry = {}\\n wing_entry['uid'] = wing.uid\\n wing_entry['symmetry'] = wing.symmetry\\n\\n # ====== Segments =====\\n wing_entry['segments'] = []\\n for segment in wing.segments.values():\\n segment_entry = {}\\n segment_entry['uid'] = segment.uid\\n segment_entry['vertices'] = dict(segment.vertices)\\n\\n segment_entry['geometry'] = {}\\n for key, value in segment.geometry.items():\\n segment_entry['geometry'][key] = value\\n\\n segment_entry['airfoils'] = {}\\n for key, value in segment.airfoils.items():\\n # If airfoil is \\\"blade\\\" file, make sure to save as relative path\\n # Note: Airfoil definition may also be for instance \\\"NACA1234\\\"\\n if \\\"blade.\\\" in value:\\n # Make path relative!\\n value = os.path.join(PATHS.DIR.AIRFOILS, os.path.basename(value))\\n segment_entry['airfoils'][key] = value\\n\\n segment_entry['panels'] = {}\\n for key, value in segment.panels.items():\\n segment_entry['panels'][key] = value\\n\\n wing_entry['segments'].append(segment_entry)\\n\\n # ====== Controls =====\\n wing_entry['controls'] = []\\n for control in wing.controls.values():\\n control_entry = {}\\n\\n control_entry['uid'] = control.uid\\n control_entry['device_type'] = control.device_type\\n control_entry['deflection'] = control.deflection\\n control_entry['deflection_mirror'] = control.deflection_mirror\\n\\n control_entry['segment_uid'] = {}\\n for key, value in control.segment_uid.items():\\n control_entry['segment_uid'][key] = value\\n\\n control_entry['rel_vertices'] = {}\\n for key, value in control.rel_vertices.items():\\n control_entry['rel_vertices'][key] = value\\n\\n control_entry['rel_hinge_vertices'] = {}\\n for key, value in control.rel_hinge_vertices.items():\\n control_entry['rel_hinge_vertices'][key] = value\\n\\n control_entry['panels'] = {}\\n for key, value in control.panels.items():\\n control_entry['panels'][key] = value\\n\\n wing_entry['controls'].append(control_entry)\\n\\n output['wings'].append(wing_entry)\\n\\n with open(filepath, 'w') as fp:\\n dump_pretty_json(output, fp)\",\n \"def dumpme(self) :\\n fileName = \\\"./data/oP4_ModelBuilder.dump\\\"\\n with open(fileName,\\\"wb\\\") as dumpedFile:\\n oPickler = pickle.Pickler(dumpedFile)\\n oPickler.dump(self)\",\n \"def save(self, json_path):\\n with open(json_path, 'w') as f:\\n json.dump(self.__dict__, f, indent = 4)\",\n \"def save(self):\\n # Create needed subfolder if not yet exist\\n f = get_subfolder(f\\\"population{'_backup' if self.use_backup else ''}/storage/\\\", f'{self.folder_name}')\\n if len(str(self).split(\\\"/\\\")) > 1: get_subfolder(f, f'{str(self).split(\\\"/\\\")[0]}')\\n f = get_subfolder(f, f'{self}')\\n f = get_subfolder(f, 'generations')\\n \\n # Save the population\\n store_pickle(self, f'{f}gen_{self.generation:05d}')\\n self.log(f\\\"Population '{self}' saved! Current generation: {self.generation}\\\")\",\n \"def setMaterial(self,massFraction,polymer):\\n M = Materials()\\n num = self.material['Detector']['mt']\\n if polymer == 'PS':\\n self.material['Detector']['matString'] = M.GetPSLiF(massFraction,num)\\n elif polymer == 'PEN':\\n self.material['Detector']['matString'] = M.GetPENLiF(massFraction,num)\\n else:\\n raise ValueError('Polymer {} is not in the material database'.format(polymer))\",\n \"def update_makes_file(target_make=None):\\n persisted_makes = load_make_models_json()\\n persisted_makes_by_slug = {make[\\\"make_slug\\\"]: make for make in persisted_makes}\\n\\n all_makes = fetch_all_makes()\\n for make in tqdm(all_makes):\\n if make[\\\"make_name\\\"] == \\\"FISKER AUTOMOTIVE\\\":\\n # This is a dumb name that doesn't match canada's name.\\n make[\\\"make_name\\\"] = \\\"Fisker\\\"\\n make[\\\"make_slug\\\"] = \\\"fisker\\\"\\n if make[\\\"make_id\\\"] == 1033:\\n # Skip the generic \\\"FISKER\\\" make, which lists no cars for some reason.\\n continue\\n if target_make and target_make != make[\\\"make_slug\\\"]:\\n continue\\n\\n if make_is_whitelisted(make, warn_if_unlisted=True):\\n persisted_makes_by_slug[make[\\\"make_slug\\\"]] = make\\n print(f\\\"{make['make_name']} produces passenger vehicles: {make}\\\")\\n else:\\n continue\\n\\n if not make_produces_passenger_vehicles(make[\\\"make_id\\\"]):\\n # There are too many random car brands, so we focus on just those makings cars and/or trucks\\n continue\\n\\n makes_and_models = list(sorted(persisted_makes_by_slug.values(), key=lambda make: make[\\\"make_slug\\\"]))\\n persist_json_file(makes_and_models, \\\"data\\\", \\\"makes_and_models.json\\\")\",\n \"def saveObjectMaps(self):\\n if self.objectMaps == None: return\\n path = os.path.join(self.dir,settings['mosh.modInfos.objectMaps'])\\n outDir = os.path.split(path)[0]\\n if not os.path.exists(outDir): os.makedirs(outDir)\\n cPickle.dump(self.objectMaps,open(path,'wb'),2)\",\n \"def save(self):\\n\\n\\t\\tdirectory = os.path.dirname(self.path)\\n\\n\\t\\tif not os.path.exists(directory):\\n\\t\\t\\tos.makedirs(directory)\\n\\n\\t\\twith open(self.path, \\\"w\\\") as f:\\n\\t\\t\\tf.write(\\n\\t\\t\\t\\tjson.dumps(\\n\\t\\t\\t\\t\\tself.dump(),\\n\\t\\t\\t\\t\\tindent=4,\\n\\t\\t\\t\\t\\tsort_keys=True\\n\\t\\t\\t\\t)\\n\\t\\t\\t)\",\n \"def save(self, json_path):\\n with open(json_path, 'w') as f:\\n json.dump(self.__dict__, f, indent=4)\",\n \"def save(self, json_path):\\n with open(json_path, 'w') as f:\\n json.dump(self.__dict__, f, indent=4)\",\n \"def save(self, json_path):\\n with open(json_path, 'w') as f:\\n json.dump(self.__dict__, f, indent=4)\",\n \"def save(self):\\n\\n with open(FileStorage.__file_path, \\\"w\\\") as file:\\n dictionary = {}\\n for a, b in FileStorage.__objects.items():\\n dictionary[a] = b.to_dict()\\n ink = json.dumps(dictionary)\\n file.write(ink)\",\n \"def saver(filename = None):\\n save(self, filename)\",\n \"def save(self, filename, path=None):\\n import os\\n\\n if path is None:\\n from art import DATA_PATH\\n full_path = os.path.join(DATA_PATH, filename)\\n else:\\n full_path = os.path.join(path, filename)\\n folder = os.path.split(full_path)[0]\\n if not os.path.exists(folder):\\n os.makedirs(folder)\\n\\n self._model.save(str(full_path))\\n logger.info('Model saved in path: %s.', full_path)\",\n \"def save(self, filename):\\n data = {\\\"sizes\\\": self.sizes,\\n \\\"weights\\\": [w.tolist() for w in self.weights],\\n \\\"biases\\\": [b.tolist() for b in self.biases]}\\n f = open(filename, \\\"w\\\")\\n json.dump(data, f)\\n f.close()\",\n \"def save(self, filename='mesh.json', verbose=False):\\n\\n f = os.path.abspath(filename) # make sure we are working with abs path\\n with open(f, 'w') as outfile:\\n json.dump(self.serialize(), outfile)\\n\\n if verbose is True:\\n print('Saved {}'.format(f))\\n\\n return f\",\n \"def savemat(self, file_name):\\n d = {'dG0_prime': self.dG0_prime,\\n 'dG0': self.dG0,\\n 'T': self.T,\\n 'I': self.I,\\n 'pH': self.pH,\\n 'pMg': self.pMg,\\n 'weight': self.weight,\\n 'cids': self.cids,\\n 'S': self.S.values}\\n savemat(file_name, d, oned_as='row')\",\n \"def saveSettings(self):\\n helpers.saveFile(self.dataDir, self.settingsFilename, json.dumps(self.settings))\",\n \"def save(self, projectData, filename):\\n f = open(filename, 'wb')\\n pickle.dump(projectData, f, protocol=1)\\n f.close()\",\n \"def save(self, uri):\\r\\n pf = PyFolder(os.path.dirname(os.path.realpath(uri)), allow_override=True)\\r\\n pf[os.path.basename(uri)+\\\"_options.json\\\"] = {\\r\\n 'input_cells': self._input_cells,\\r\\n 'latent_space': self._latent_space,\\r\\n }\\r\\n\\r\\n save_model(self._autoencoder, uri+\\\"_lstm_autoencoder.hdf5\\\")\\r\\n save_model(self._encoder, uri+\\\"_lstm_encoder.hdf5\\\")\",\n \"def save(self):\\n\\n toStore = {\\n key: obj.to_dict()\\n for key, obj in FileStorage.__objects.items()\\n }\\n with open(FileStorage.__file_path, 'wt') as file:\\n json.dump(toStore, file)\",\n \"def store(self, file=None):\\n params = self.info()\\n if not file:\\n folder = os.path.dirname(self.file)\\n assert os.path.isdir(folder)\\n file = os.path.join(folder, self.generate_name() + \\\".json\\\")\\n assert os.path.splitext(file)[1] == \\\".json\\\"\\n self.file = file\\n self.tf_checkpoint_path = os.path.splitext(file)[0]\\n if os.path.isfile(file):\\n print(\\\"Overwriting '{}' ...\\\".format(self.tf_checkpoint_path))\\n else:\\n print(\\\"Creating '{}' ...\\\".format(self.tf_checkpoint_path))\\n with open(file, 'w') as open_file:\\n json.dump(params, open_file, indent=2, sort_keys=True)\",\n \"def save(self):\\n data = \\\"\\\"\\n for y in xrange(0, BLOCK_NUM_HEIGHT):\\n for x in xrange(0, BLOCK_NUM_WIDTH):\\n data += self.blocks[y][x]\\n data += '\\\\n'\\n print data\\n options = {'defaultextension': '.lvl',\\n 'filetypes': [('Levels', '.lvl'), ('All files', '*')],\\n 'initialdir': 'levels',\\n 'initialfile': '',\\n 'title': 'Save level'}\\n # filename = tkFileDialog.asksaveasfile(**options)\\n filename = asksaveasfilename(**options)\\n if filename:\\n with open(filename, \\\"w\\\") as level:\\n level.write(data)\",\n \"def save(self, filename=\\\"matpipe.p\\\"):\\n temp_backend = self.learner.backend\\n self.learner._backend = self.learner.backend.fitted_pipeline_\\n for obj in [self, self.learner, self.reducer, self.cleaner,\\n self.autofeaturizer]:\\n obj._logger = None\\n with open(filename, 'wb') as f:\\n pickle.dump(self, f)\\n self.learner._backend = temp_backend\",\n \"def _write(self, preset_type, data):\\n logger.debug('write presets for %s', self._device.name)\\n with self._file_open_rlock(preset_type) as f:\\n f.seek(0)\\n yaml.dump(data, f, default_flow_style=False)\\n f.truncate()\",\n \"def save(self, file=\\\"setup\\\", path=\\\"settings\\\"):\\n\\n # check if filename already contains file extension, if not, add it\\n if file[-5:] != '.json':\\n file += '.json'\\n # save mappings data to file\\n with open(os.path.join(path, file), 'w') as file:\\n json.dump(self.data, file)\",\n \"def save(self):\\n # Ensure store path exists\\n store_path = self.manager.store_path\\n if not os.path.exists(store_path):\\n os.makedirs(store_path)\\n \\n # Get filepath\\n filename = self._filename\\n \\n # Write into file\\n raw = self.to_json()\\n self.service.log.store('Saving %s' % filename)\\n f = open(filename, 'w')\\n f.write(raw)\\n f.close()\",\n \"def save_training(self):\\n\\n filename = str(hashlib.sha1(str(self.training_data).encode(\\\"utf-8\\\"))\\n .hexdigest())\\n path = \\\"./training/\\\" + filename + \\\".json\\\"\\n\\n data = {\\n \\\"states\\\": self.states,\\n \\\"transitions\\\": self.transitions,\\n \\\"matrix\\\": self.matrix.tolist()\\n }\\n\\n with open(path, \\\"w\\\") as outfile:\\n json.dump(data, outfile)\",\n \"def save_root(self, filename=None):\\n if not filename:\\n filename = tkFileDialog.asksaveasfilename()\\n if filename:\\n maketree.populate(self.initial.itervalues(),\\n self.detectors.itervalues())\\n maketree.write(filename)\",\n \"def save_as_mat(data, name=\\\"model\\\"):\\n import scipy.io as sio\\n\\n # sio.savemat(name'.mat',{name:b})\\n sio.savemat(name + \\\".mat\\\", {name: data})\",\n \"def save(self):\\n if PYTHON3:\\n fileobj = open(self.filename, 'w', encoding=self.ENCODING, errors=\\\"replace\\\")\\n else:\\n fileobj = open(self.filename, 'w')\\n self.save_to_fileobj(fileobj)\\n fileobj.close()\",\n \"def save(self, dir_name=None):\\n root_dir = os.getcwd()\\n cur_datetime = str(datetime.datetime.now()).split(\\\".\\\")[0] # remove fractional seconds\\n if not dir_name:\\n dir_name = \\\"game_\\\" + cur_datetime + \\\"/\\\"\\n save_dir = root_dir + \\\"/saved_games/\\\" + dir_name + \\\"_\\\" + cur_datetime + \\\"/\\\"\\n\\n # Check if the filepath already exists\\n if not os.path.exists(save_dir):\\n os.makedirs(save_dir)\\n\\n # Game\\n game_dir = save_dir + \\\"game/\\\"\\n os.makedirs(game_dir)\\n with open(game_dir + \\\"game.json\\\", \\\"w\\\") as file_handle:\\n game_dict = self.to_json_dict()\\n json.dump(game_dict, file_handle)\\n\\n # Player\\n player_dir = save_dir + \\\"player/\\\"\\n os.makedirs(player_dir)\\n with open(player_dir + \\\"player.json\\\", \\\"w\\\") as file_handle:\\n player_dict = self.player.to_json_dict()\\n json.dump(player_dict, file_handle)\\n\\n # Items\\n items_dir = save_dir + \\\"items/\\\"\\n os.makedirs(items_dir)\\n for i in self.items:\\n with open(items_dir + i.get_name() + \\\"_\\\" + str(i.get_id()) + \\\".json\\\", \\\"w\\\") as file_handle:\\n item_dict = i.to_json_dict()\\n json.dump(item_dict, file_handle)\\n\\n # Characters\\n characters_dir = save_dir + \\\"characters/\\\"\\n os.makedirs(characters_dir)\\n for c in self.characters:\\n with open(characters_dir + c.get_name() + \\\"_\\\" + str(c.get_id()) + \\\".json\\\", \\\"w\\\") as file_handle:\\n character_dict = c.to_json_dict()\\n json.dump(character_dict, file_handle)\\n\\n # Spaces\\n spaces_dir = save_dir + \\\"spaces/\\\"\\n os.makedirs(spaces_dir)\\n for s in self.spaces:\\n with open(spaces_dir + s.get_name() + \\\"_\\\" + str(s.get_id()) + \\\".json\\\", \\\"w\\\") as file_handle:\\n spaces_dict = s.to_json_dict()\\n json.dump(spaces_dict, file_handle)\\n\\n # Exits\\n exits_dir = save_dir + \\\"exits/\\\"\\n os.makedirs(exits_dir)\\n for e in self.exits:\\n with open(exits_dir + e.get_name() + \\\"_\\\" + str(e.get_id()) + \\\".json\\\", \\\"w\\\") as file_handle:\\n exits_dict = e.to_json_dict()\\n json.dump(exits_dict, file_handle)\",\n \"def save(self):\\n self.lock.acquire()\\n try:\\n self.xml.set(\\\"name\\\",self.name)\\n self.xml.set(\\\"room\\\",self.room)\\n self.xml.set(\\\"type\\\",self.type)\\n self.xml.find(\\\"address\\\").text = \\\":\\\".join([str(x) for x in self.address])\\n if self.pos is not None:\\n self.xml.find(\\\"pos\\\").text = \\\" \\\".join([str(x) for x in self.pos])\\n self.xml.find(\\\"icon\\\").text = self.icon\\n \\n finally:\\n self.lock.release()\\n \\n self.house.save_devices()\",\n \"def save(self, path):\\n if path.endswith(\\\".gz\\\"):\\n file = gzip.open(path, \\\"w\\\", 9)\\n else:\\n file = open(path, \\\"wb\\\")\\n\\n # update the settings in the data to the latest value\\n data = json.loads(self.value)\\n data[\\\"settings\\\"] = self.settings\\n\\n file.write(json.dumps(data).encode(\\\"utf8\\\"))\\n file.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57051945","0.55286336","0.54615587","0.53826904","0.5350502","0.53496337","0.5319556","0.52859074","0.5285472","0.52815086","0.5229431","0.5202984","0.5185666","0.5141686","0.5140259","0.513041","0.51060146","0.5105606","0.50921017","0.5083165","0.5072597","0.50634295","0.50603575","0.50601643","0.5031712","0.5016729","0.4997566","0.4988507","0.49884725","0.4957583","0.4953412","0.4932087","0.49268728","0.49133462","0.48966336","0.48966336","0.48881665","0.48849356","0.48841685","0.4878622","0.48684347","0.48544347","0.48509106","0.48427403","0.4842499","0.48400858","0.4835588","0.48325646","0.48279443","0.4827573","0.48093584","0.48024896","0.47998542","0.47979054","0.47962317","0.4770425","0.47696048","0.47669035","0.47666064","0.4764619","0.47591543","0.47540972","0.4746854","0.47439","0.47400868","0.4737125","0.47353977","0.47351545","0.47294658","0.47260055","0.4721709","0.4721595","0.4718116","0.4716243","0.47155356","0.47155356","0.47155356","0.47152436","0.47151843","0.47083977","0.46986645","0.46939287","0.46922138","0.4686666","0.46823832","0.4676022","0.46758276","0.46746403","0.46741337","0.46737993","0.46649662","0.46649566","0.46642447","0.4663662","0.46615082","0.46613178","0.46603063","0.46584737","0.46551445","0.4647729"],"string":"[\n \"0.57051945\",\n \"0.55286336\",\n \"0.54615587\",\n \"0.53826904\",\n \"0.5350502\",\n \"0.53496337\",\n \"0.5319556\",\n \"0.52859074\",\n \"0.5285472\",\n \"0.52815086\",\n \"0.5229431\",\n \"0.5202984\",\n \"0.5185666\",\n \"0.5141686\",\n \"0.5140259\",\n \"0.513041\",\n \"0.51060146\",\n \"0.5105606\",\n \"0.50921017\",\n \"0.5083165\",\n \"0.5072597\",\n \"0.50634295\",\n \"0.50603575\",\n \"0.50601643\",\n \"0.5031712\",\n \"0.5016729\",\n \"0.4997566\",\n \"0.4988507\",\n \"0.49884725\",\n \"0.4957583\",\n \"0.4953412\",\n \"0.4932087\",\n \"0.49268728\",\n \"0.49133462\",\n \"0.48966336\",\n \"0.48966336\",\n \"0.48881665\",\n \"0.48849356\",\n \"0.48841685\",\n \"0.4878622\",\n \"0.48684347\",\n \"0.48544347\",\n \"0.48509106\",\n \"0.48427403\",\n \"0.4842499\",\n \"0.48400858\",\n \"0.4835588\",\n \"0.48325646\",\n \"0.48279443\",\n \"0.4827573\",\n \"0.48093584\",\n \"0.48024896\",\n \"0.47998542\",\n \"0.47979054\",\n \"0.47962317\",\n \"0.4770425\",\n \"0.47696048\",\n \"0.47669035\",\n \"0.47666064\",\n \"0.4764619\",\n \"0.47591543\",\n \"0.47540972\",\n \"0.4746854\",\n \"0.47439\",\n \"0.47400868\",\n \"0.4737125\",\n \"0.47353977\",\n \"0.47351545\",\n \"0.47294658\",\n \"0.47260055\",\n \"0.4721709\",\n \"0.4721595\",\n \"0.4718116\",\n \"0.4716243\",\n \"0.47155356\",\n \"0.47155356\",\n \"0.47155356\",\n \"0.47152436\",\n \"0.47151843\",\n \"0.47083977\",\n \"0.46986645\",\n \"0.46939287\",\n \"0.46922138\",\n \"0.4686666\",\n \"0.46823832\",\n \"0.4676022\",\n \"0.46758276\",\n \"0.46746403\",\n \"0.46741337\",\n \"0.46737993\",\n \"0.46649662\",\n \"0.46649566\",\n \"0.46642447\",\n \"0.4663662\",\n \"0.46615082\",\n \"0.46613178\",\n \"0.46603063\",\n \"0.46584737\",\n \"0.46551445\",\n \"0.4647729\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65841603"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3190,"cells":{"query":{"kind":"string","value":"Create a new Settings, reading from a default location for the given domain (~/Library/Preferences/%s.plist)."},"document":{"kind":"string","value":"def __init__(self, domain='com.markfickett.gors'):\n\t\tsettingsDir = os.path.expanduser(self.__SETTINGS_DIR)\n\t\tif not os.path.isdir(settingsDir):\n\t\t\tos.makedirs(settingsDir)\n\t\tself.__settingsFileName = os.path.join(settingsDir,\n\t\t\tdomain + '.plist')\n\t\tif os.path.isfile(self.__settingsFileName):\n\t\t\tself.__settings = plistlib.readPlist(\n\t\t\t\tself.__settingsFileName)\n\t\telse:\n\t\t\tself.clear()\n\t\tself.__currentGroupNames = []"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def settings_create(ctx):\n # Choose where and whether to save the configuration file.\n path = ctx.obj['load_path']\n if path:\n click.confirm(\n 'A settings file already exists. Continuing will override it. '\n 'Do you want to continue?',\n abort=True,\n )\n else:\n path = ctx.obj['save_path']\n\n # Get information about Pulp.\n pulp_config = {'pulp': _get_pulp_properties()}\n pulp_config['hosts'] = [\n _get_host_properties(pulp_config['pulp']['version'])\n ]\n pulp_config['pulp']['version'] = str(pulp_config['pulp']['version'])\n try:\n config.validate_config(pulp_config) # This should NEVER fail!\n except exceptions.ConfigValidationError:\n print(\n 'An internal error has occurred. Please report this to the Pulp '\n 'Smash developers at https://github.com/PulpQE/pulp-smash/issues',\n file=sys.stderr,\n )\n raise\n\n # Write the config to disk.\n with open(path, 'w') as handler:\n handler.write(json.dumps(pulp_config, indent=2, sort_keys=True))\n click.echo('Settings written to {}.'.format(path))","def open_settings(location, show_defaults=False, settings_type=None, **kwargs):\n prefs = kwargs.get('prefs', settings.InternalSettings())\n if settings_type:\n settings_type = settings_type.lower()\n\n target_path = prefs.get_settings_path(location, settings_type)\n if not target_path.exists():\n dirname = target_path.parent\n makedirs(dirname, mode=0o775, exist_ok=True)\n with open(target_path, 'a', newline='\\n') as settings_file:\n settings_file.write('{}')\n\n if show_defaults:\n openable = [prefs.get_settings_path('default', settings_type, target_path.suffix), target_path]\n else:\n openable = [target_path]\n return result.Success(openable=openable)","def load_settings_from_cli():\n load_user_from_cli()\n load_local_contacts()","def loadSettings(home_dir,pd_dir):\n\n settingsXML = os.path.join(pd_dir,\"settings.xml\")\n\n #print(\"Loading settings from {0}\".format(settingsXML))\n\n global installationTree\n global installationSettings\n global domainPath\n global userEmail\n global userToken\n\n if os.path.isfile(settingsXML):\n installationTree = etree.parse(settingsXML)\n installationSettings = installationTree.getroot()\n\n for child in installationSettings:\n if child.tag == \"domain_path\":\n domainPath = child.text\n\n if not os.path.isdir(domainPath):\n fetchPlanningDomains(domainPath)\n\n if child.tag == \"email\":\n userEmail = child.text\n\n if child.tag == \"token\":\n userToken = child.text\n\n return\n\n if installationSettings is None:\n installationSettings = etree.Element(\"{http://settings.planning.domains}settings\")\n installationTree = etree.ElementTree(installationSettings)\n\n domainPath = input(\"Enter path for installing files (or hit enter to use {0}): \".format(os.path.join(home_dir,\"planning.domains\")))\n\n domainPath = domainPath.lstrip()\n domainpath = domainPath.rstrip()\n\n if domainPath == \"\":\n domainPath = os.path.join(home_dir,\"planning.domains\")\n\n if os.path.isfile(domainPath):\n print(\"Fatal error: there is already a file called {0}\".format(domainPath))\n exit(1)\n\n if not os.path.isdir(domainPath):\n fetchPlanningDomains(domainPath)\n\n etree.SubElement(installationSettings,\"domain_path\").text = domainPath\n\n userEmail = input(\"Enter email for API updates: \")\n userToken = input(\"Enter token for API updates (leave blank if none provided): \")\n\n etree.SubElement(installationSettings,\"email\").text = userEmail\n etree.SubElement(installationSettings,\"token\").text = userToken\n\n saveSettings()","def set_by_domain(domain):\r\n if not has_configuration_set() or not domain:\r\n return\r\n\r\n for key, value in settings.MICROSITE_CONFIGURATION.items():\r\n subdomain = value.get('domain_prefix')\r\n if subdomain and domain.startswith(subdomain):\r\n _set_current_microsite(key, subdomain, domain)\r\n return\r\n\r\n # if no match on subdomain then see if there is a 'default' microsite defined\r\n # if so, then use that\r\n if 'default' in settings.MICROSITE_CONFIGURATION:\r\n _set_current_microsite('default', subdomain, domain)","def make_pref_file():\r\n pref_dict = {\"default_user\": None}\r\n\r\n with open(os.path.join(os.path.dirname(__file__), \"preferences.json\"), \"w\") as pref:\r\n pref.write(json.dumps(pref_dict, indent=4))\r\n\r\n return pref_dict","def create_domain(self, domain: str) -> Session:\n uri = f\"{self.uri}/domains\"\n data = {\n \"hostname\": domain\n }\n response = self.request(uri=uri, method=\"POST\", data=data)\n\n return response","def create_default_settings():\n from flaskbb.fixtures.settings import fixture\n create_settings_from_fixture(fixture)","def make_settings(pypirc):\n default_pypirc = \"\"\"\n [pypi]\n username:foo\n password:bar\n \"\"\"\n\n def _settings(pypirc_text=default_pypirc, **settings_kwargs):\n pypirc.write(textwrap.dedent(pypirc_text))\n\n settings_kwargs.setdefault(\"sign_with\", None)\n settings_kwargs.setdefault(\"config_file\", str(pypirc))\n\n return settings.Settings(**settings_kwargs)\n\n return _settings","def load_settings(self):\n\n self.domains = []\n self.clear_settings()\n api_keys = self.api_key_instance.get_api_keys()\n if api_keys:\n for domain, api_key in list(api_keys.items()):\n self.domains.append(domain)\n getattr(self.dlg, \"uTextDomain{0}\".format(len(self.domains))).setText(\n domain\n )\n getattr(self.dlg, \"uTextAPIKey{0}\".format(len(self.domains))).setText(\n api_key\n )\n\n # Hide un-populated domain rows\n for entry in range(len(self.domains) + 1, 11):\n getattr(self.dlg, \"uTextDomain{0}\".format(entry)).hide()\n getattr(self.dlg, \"uTextAPIKey{0}\".format(entry)).hide()\n getattr(self.dlg, \"uBtnRemoveDomain{0}\".format(entry)).hide()\n getattr(self.dlg, \"uBtnSaveDomain{0}\".format(entry)).hide()","def create_domain(DomainName=None):\n pass","def get_domain_config():\n query = {\n \"type\": \"config\",\n \"action\": \"get\",\n \"xpath\": \"/config/devices/entry[@name='localhost.localdomain']/deviceconfig/system/domain\",\n }\n\n return __proxy__[\"panos.call\"](query)","def populate_domain_data(self, domain):\n self.domain_resolve(domain)\n domain_data = server.get_domain_data(domain)['data']['userdata']\n\n self.domain_data[domain] = self.domain_resolve(domain)\n\n if domain in self.domain_data.keys():\n try:\n self.domain_data[domain]['documentroot'] = domain_data['documentroot']\n self.domain_data[domain]['ip'] = domain_data['ip']\n except KeyError:\n self.domain_data[domain]['documentroot'] = \"No domain data found, admin should check\"\n self.domain_data[domain]['ip'] = \"No domain data found, admin should check\"","def get_domain_config(self, defaultcfg, wireframe):\n\n dnsdata = dnslib.DNSRecord.parse(wireframe)\n dnsdomain = dnsdata.q.get_qname()\n\n for ruleset in globals.config.rules.match:\n if re.search(str(ruleset.domain), str(dnsdomain)):\n # domain config matches!\n return Box({**defaultcfg, **ruleset})\n\n return defaultcfg","def __init__(__self__, *,\n domain: pulumi.Input[str]):\n pulumi.set(__self__, \"domain\", domain)","def __init__(__self__, *,\n domain: pulumi.Input[str]):\n pulumi.set(__self__, \"domain\", domain)","def loadSettings():\r\n try:\r\n settingsFile = open(sys.argv[1], \"r\")\r\n except IOError:\r\n logging.exception(\"Error opening settings.\")\r\n exitApp()\r\n \r\n settingStr = settingsFile.read()\r\n settingsFile.close()\r\n \r\n try:\r\n settings = json.loads(settingStr)\r\n except ValueError:\r\n logging.exception(\"Error parsing settings.\")\r\n exitApp()\r\n \r\n # Check integrity\r\n if (len(settings[\"reddit_username\"]) == 0):\r\n logging.critical(\"Reddit username not set.\")\r\n exitApp()\r\n \r\n if (len(settings[\"reddit_password\"]) == 0):\r\n logging.critical(\"Reddit password not set.\")\r\n exitApp()\r\n \r\n if (len(settings[\"reddit_subreddit\"]) == 0):\r\n logging.critical(\"Subreddit not set.\")\r\n exitApp()\r\n \r\n if (len(settings[\"reddit_ua\"]) == 0):\r\n logging.critical(\"Reddit bot user agent not set.\")\r\n exitApp()\r\n \r\n settings[\"repost_protection\"] = bool(settings[\"repost_protection\"])\r\n \r\n return settings","def default_user_settings(self) -> pulumi.Input['DomainUserSettingsArgs']:\n return pulumi.get(self, \"default_user_settings\")","def load_from_defaults(self):\n default_settings = import_module('mindinsight.conf.defaults')\n for setting in dir(default_settings):\n if setting.isupper():\n setattr(self, setting, getattr(default_settings, setting))\n self._default_settings.add(setting)","def create_default_config():\n import codecs\n config = ConfigParser.SafeConfigParser()\n config.readfp(StringIO(DEFAULT_CONFIG))\n\n # Load user settings\n filename = get_user_config_filename()\n if not os.path.exists(filename):\n from wizard import setup_wizard\n setup_wizard(config)\n else:\n try:\n fi = codecs.open(filename, 'r', encoding='utf-8')\n config.readfp(fi)\n finally:\n fi.close()\n return config","def generate_settings():\r\n conf_file = os.path.join(os.path.dirname(base_settings.__file__),\r\n 'example', 'conf.py')\r\n conf_template = open(conf_file).read()\r\n default_url = 'http://salmon.example.com'\r\n site_url = raw_input(\"What will be the URL for Salmon? [{0}]\".format(\r\n default_url))\r\n site_url = site_url or default_url\r\n secret_key = base64.b64encode(os.urandom(KEY_LENGTH))\r\n api_key = base64.b64encode(os.urandom(KEY_LENGTH))\r\n output = conf_template.format(api_key=api_key, secret_key=secret_key,\r\n site_url=site_url)\r\n return output","def set_domain(domain):\n set_hosts(domain)\n click.echo(\n 'Host file was set: {} -> 127.0.0.1'.format(', '.join(domain))\n )","def setup_domain(domain):\n bucket = BUCKET_MANAGER.get_bucket(domain)\n\n zone = DOMAIN_MANAGER.find_hosted_zone(domain) \\\n or DOMAIN_MANAGER.create_hosted_zone(domain)\n\n endpoint = util.get_endpoint(BUCKET_MANAGER.get_region_name(bucket))\n a_record = DOMAIN_MANAGER.create_s3_domain_record(zone, domain, endpoint)\n print(\"Domain configure: http://{}\".format(domain))\n print(\"A record created: {}\".format(a_record))","def init_settings(self):\n if not os.path.exists(self.settingsFilePath):\n settings_dir = os.getenv(\"APPDATA\") + \"\\\\\" + qApp.applicationName()\n if not os.path.exists(settings_dir):\n os.makedirs(settings_dir)\n setting_path = \"\"\n if getattr(sys, 'frozen', False):\n setting_path = os.path.dirname(sys.executable)\n elif __file__:\n setting_path = os.path.dirname(__file__)\n shutil.copyfile(os.path.join(setting_path, \"resources\\eksettings.ini\"), self.settingsFilePath)\n return","def findSettingsFile():\n settingsName = 'oct-fire-settings.json'\n userPath = os.path.expanduser('~')\n if os.path.exists(settingsName):\n return settingsName\n elif os.path.exists(os.path.join(userPath, settingsName)):\n return os.path.join(userPath, settingsName)\n elif os.path.exists(os.path.join(userPath, 'Desktop', settingsName)):\n return os.path.join(userPath, 'Desktop', settingsName)\n elif os.path.exists(os.path.join(userPath, 'Documents', settingsName)):\n return os.path.join(userPath, 'Documents', settingsName)\n elif os.path.exists(os.path.join(userPath, 'Downloads', settingsName)):\n return os.path.join(userPath, 'Downloads', settingsName)\n raise Exception('Could not locate settings file')","def ini(filename, **defaults):\n filename = sh.path(filename)\n defaults.update(home=sh.path('~'))\n return ConfigObject(filename=filename, defaults=defaults)","def __init__(self, settings, valid, defaults=None):\n\n try:\n with open(settings, 'r') as settings_file:\n self._settings = json.load(settings_file)\n except TypeError:\n self._settings = dict(settings)\n self._settings = Settings._inject_defaults(self._settings, defaults)\n Settings._validity_check(self._settings, valid)","def getDefaultSettings(self) -> ghidra.docking.settings.Settings:\n ...","def set_domain_path(self):\n\n self.domain_path = os.path.join(self.docs_path, self.domain)\n if not os.path.exists(self.domain_path):\n os.makedirs(self.domain_path)","def settings() -> Settings:\n return Settings()","def load_settings(self):\n\n self.std = settings.settings","def pref(pref_name):\n default_prefs = {\n 'ServerURL': 'http://sal',\n }\n pref_value = CFPreferencesCopyAppValue(pref_name, BUNDLE_ID)\n if pref_value == None:\n pref_value = default_prefs.get(pref_name)\n # we're using a default value. We'll write it out to\n # /Library/Preferences/<BUNDLE_ID>.plist for admin\n # discoverability\n set_pref(pref_name, pref_value)\n if isinstance(pref_value, NSDate):\n # convert NSDate/CFDates to strings\n pref_value = str(pref_value)\n return pref_value","def from_settings(settings):","def load_settings(self, outfile='settings.p'):\n settings = pickle.load(open(path,'rb'))\n self.__dict__.update(settings)","def set_domain(self, var, domain) :\n if var not in self.variables :\n raise KeyError(str(var) + \" is not a variable in this problem.\")\n self.domains[var] = sorted(domain[:])\n return self","def get_settings(hostname: Optional[str] = None, device_type: Optional[DeviceType] = None):\n with open('/etc/cnaas-nms/repository.yml', 'r') as repo_file:\n repo_config = yaml.safe_load(repo_file)\n\n local_repo_path = repo_config['settings_local']\n try:\n verify_dir_structure(local_repo_path, DIR_STRUCTURE)\n except VerifyPathException as e:\n logger.exception(\"Exception when verifying settings repository directory structure\")\n raise e\n\n # 1. Get CNaaS-NMS default settings\n data_dir = pkg_resources.resource_filename(__name__, 'data')\n with open(os.path.join(data_dir, 'default_settings.yml'), 'r') as f_default_settings:\n settings: dict = yaml.safe_load(f_default_settings)\n\n settings_origin = {}\n for k in settings.keys():\n settings_origin[k] = 'default'\n\n # 2. Get settings repo global settings\n settings, settings_origin = read_settings(\n local_repo_path, ['global', 'base_system.yml'], 'global', settings, settings_origin)\n # 3. Get settings from special fabric classification (dist + core)\n if device_type and (device_type == DeviceType.DIST or device_type == DeviceType.CORE):\n settings, settings_origin = read_settings(\n local_repo_path, ['fabric', 'base_system.yml'], 'fabric',\n settings, settings_origin)\n # 4. Get settings repo device type settings\n if device_type:\n settings, settings_origin = read_settings(\n local_repo_path, [device_type.name.lower(), 'base_system.yml'], 'devicetype',\n settings, settings_origin)\n # 5. Get settings repo device specific settings\n if hostname:\n if os.path.isdir(os.path.join(local_repo_path, 'devices', hostname)):\n settings, settings_origin = read_settings(\n local_repo_path, ['devices', hostname, 'base_system.yml'], 'device',\n settings, settings_origin)\n # Verify syntax\n check_settings_syntax(settings, settings_origin)\n return f_root(**settings).dict(), settings_origin","def setup_settings():\n # pylint: disable=import-outside-toplevel\n from django.conf import settings\n import tiny_erp.settings as defaults\n\n for name in dir(defaults):\n if name.isupper() and not hasattr(settings, name):\n setattr(settings, name, getattr(defaults, name))","def get_preferred_domain(project=None, default_to_appid=True):\n projects_prefs = settings.PREFERRED_DOMAIN_NAMES.get(settings.APP_ID, {})\n preferred_domain = projects_prefs.get(project)\n if not preferred_domain:\n preferred_domain = projects_prefs.get(None)\n if not preferred_domain:\n if default_to_appid:\n preferred_domain = '%s.appspot.com' % app_identity.get_application_id()\n return preferred_domain","def defaultConf():\n from config import lwbdUrl, userAndPass\n baseUrl = lwbdUrl\n lucidAuth = userAndPass\n return LucidSdaConfiguration(baseUrl,\n lucidAuth)","def setPreference(self, newPreference):\n\t\tif newPreference == \"d\":\n\t\t\tself.showDomains = 1\n\t\telif newPreference == \"w\":\n\t\t\tself.showDomains = 0\n\t\telif newPreference == \"l\":\n\t\t\tself.showFullTitles = 1\n\t\telif newPreference == \"o\":\n\t\t\tself.showFullTitles = 0\n\t\telif newPreference == \"c\":\n\t\t\tself.collapseOldStories = 1\n\t\telif newPreference == \"e\":\n\t\t\tself.collapseOldStories = 0\n\t\telif newPreference[0] == \"/\":\n\t\t\tself.hnUserName = newPreference[1:]\n\n\t\twriteWentWell = self.writePreferenceToFile(newPreference)\n\t\tif not writeWentWell:\n\t\t\tinput = raw_input(\"hnsh_prefs.txt not found. Preferences changed will only be kept until this program is closed. Press Return to continue. \")","def find_settings():\n return Setting()","def default_settings(self, settings):\n return {}","def default_user_settings(self) -> pulumi.Output['outputs.DomainUserSettings']:\n return pulumi.get(self, \"default_user_settings\")","def getDefaultSettings():\n return {}","def __init__(self, bot, name, default_settings=None):\n if default_settings is None:\n default_settings = {}\n self.bot = bot\n self.name = name\n self.default_settings = default_settings\n\n # set up storage for settings and load from persistent file\n self.settings_path = pathlib.Path(\".settings\", f\"{self.name}.yml\")\n self.id_dict = load_persistent_settings(self.settings_path)","def __init__(self, location=None, default_location=None):\n RawConfigParser.__init__(self)\n\n self.location = location\n self._saving = False\n self._dirty = False\n\n if default_location is not None:\n try:\n self.read(default_location)\n except:\n pass\n\n if location is not None:\n try:\n self.read(self.location) or \\\n self.read(self.location + \".new\") or \\\n self.read(self.location + \".old\")\n except:\n pass\n\n if self.get_option('settings/version', 0) is None:\n self.set_option('settings/version', self.__version__)","def __init__(self):\n for name, default in self.defaults.items():\n value = getattr(django.conf.settings, name, default)\n setattr(self, name, value)","def create_settings(root_directory, files, variables, main_file, output):\n\tfiles = [format_path(f) for f in files]\n\tvariables = format_variables(variables)\n\tsettings = {\n\t\tSETTINGS_ROOTDIR : root_directory if root_directory.endswith('/') else root_directory+'/',\n\t\tSETTINGS_FILES : files,\n\t\tSETTINGS_VARIABLES : variables,\n\t\tSETTINGS_MAIN : format_path(main_file),\n\t\tSETTINGS_OUTPUT : output + SETTINGS_OUTPUT_PATH\n\t}\n\treturn settings","def save_domain(self):\n del_domain = 0\n save_domain = 0\n\n sending_btn = self.dlg.sender().objectName()\n if sending_btn[:-1] == \"uBtnRemoveDomain\":\n del_domain = sending_btn[-1]\n if sending_btn[:-1] == \"uBtnSaveDomain\":\n save_domain = sending_btn[-1]\n\n keys = {}\n for entry in range(1, len(self.domains) + 2):\n if int(del_domain) == entry:\n continue\n domain = getattr(self.dlg, \"uTextDomain{0}\".format(entry)).text()\n key = getattr(self.dlg, \"uTextAPIKey{0}\".format(entry)).text().strip()\n if domain and key:\n keys[domain] = key\n self.api_key_instance.set_api_keys(keys)\n\n # remove store capability docs for the removed or add domain/key\n # if they already exits .i.e these will be reloaded\n if save_domain:\n ui_elem_num = save_domain\n else:\n ui_elem_num = del_domain\n\n domain = getattr(self.dlg, \"uTextDomain{0}\".format(ui_elem_num)).text()\n self.local_store.del_domains_xml(domain)\n\n # load / Reload service data\n self.load_settings()\n self.dlg.uWarningSettings.hide()\n self.dlg.uLabelWarning.hide()\n if self.curr_list_wid_index is not None:\n self.dlg.uListOptions.setCurrentItem(self.curr_list_wid_index)\n else:\n self.dlg.uListOptions.setCurrentRow(0)\n\n self.dlg.uStackedWidget.setCurrentIndex(0)\n self.services_loaded = False # key change, load data again\n self.load_ui()","def default(cls) -> 'Config':\n parser: configparser.ConfigParser = configparser.ConfigParser()\n parser.read_dict(dict(wpwatcher=Config.DEFAULT_CONFIG))\n return cls.fromparser(parser)","def get_defaults():\r\n profile = settings.profile_manager.get(\"default\")\r\n config = profile.get_config('freeseer.conf', settings.FreeseerConfig, storage_args=['Global'], read_only=True)\r\n return {\r\n \"video_directory\": config.videodir,\r\n \"oauth2_token\": os.path.join(settings.configdir, \"oauth2_token.json\"),\r\n \"client_secrets\": os.path.join(settings.configdir, \"client_secrets.json\")\r\n }","def get_defaults():\n\n # get package defaults\n with open(os.path.join(iLoop_RNAseq_pipeline.__path__[0], 'defaults', 'RNAseq_pipeline_defaults.txt')) as rpd:\n defaults = {}\n for line in rpd.readlines():\n if line.strip():\n defaults[line.split(',')[0].strip()] = line.split(',')[1].strip()\n\n try:\n with open(os.path.join(os.path.expanduser(\"~\"), 'RNAseq_pipeline_defaults.txt')) as rpd:\n for line in rpd.readlines():\n if line.strip():\n defaults[line.split(',')[0].strip()] = line.split(',')[1].strip()\n except FileNotFoundError:\n logger.warning('\"RNAseq_pipeline_defaults.txt\" does not exist under home path. An email address and project ID should be should be define in that file.')\n\n # replace with user defaults\n try:\n with open('RNAseq_pipeline_defaults.txt') as rpd:\n for line in rpd.readlines():\n if line.strip():\n defaults[line.split(',')[0].strip()] = line.split(',')[1].strip()\n except FileNotFoundError:\n logger.info(\n '\"RNAseq_pipeline_defaults.txt\" does not exist under this folder. Defaults from the package and home path will be used.')\n\n if 'email' not in defaults:\n if not validate_email(defaults['email']):\n while True:\n email = input('Enter a valid email address for job status: \\n')\n if validate_email(email):\n defaults['email'] = email\n print('Writing email to \"RNAseq_pipeline_defaults.txt\" under home path.')\n f = open(os.path.join(os.path.expanduser(\"~\"), 'RNAseq_pipeline_defaults.txt'), 'w+')\n f.write('\\nemail,{}'.format(email))\n f.close()\n break\n else:\n print('{} is not valid, try again.'.format(email))\n\n if ('project' not in defaults) or (defaults['project'] == 'projectid'):\n project = input('Enter Computerome project ID for billing: \\n')\n # TODO It is possible to validate this by checking folder name under \"/home/projects\".\n defaults['project'] = project\n print('Writing project ID to \"RNAseq_pipeline_defaults.txt\" under home path.')\n f = open(os.path.join(os.path.expanduser(\"~\"), 'RNAseq_pipeline_defaults.txt'), 'w+')\n f.write('\\nproject,{}'.format(project))\n f.close()\n\n return defaults","def initialize_settings(tool_name, source_path, dest_file_name=None):\n settings_dir = os.path.join(SETTINGS_DIRECTORY, tool_name)\n if not os.path.exists(settings_dir):\n os.mkdir(settings_dir)\n if not dest_file_name:\n dest_file_name = os.path.basename(source_path)\n settings_path = os.path.join(settings_dir, dest_file_name)\n if not os.path.exists(settings_path):\n shutil.copy(source_path, settings_path)\n else:\n try:\n SettingsMigrator(source_path, settings_path).migrate()\n except ConfigObjError, parsing_error:\n print 'WARNING! corrupted configuration file replaced with defaults'\n print parsing_error\n shutil.copy(source_path, settings_path)\n return os.path.abspath(settings_path)","def load_settings(self):\n # Set the default settings. In case in a later version of this script the settings change, new default variables will be added automatically\n self.settings = {\n # Connection settings to OBS Studio websockets plugin\n \"host\": \"localhost\",\n \"port\": 4444,\n \"password\": \"\",\n \"update_frequency\": 1, # seconds, how often the script loads the SC2 UI location\n }\n if os.path.isfile(self.settings_path):\n with open(self.settings_path) as f:\n self.settings.update(json.load(f))","def _create_default_config(self):\n self.options.setdefault('options.admin_passwd', '')\n sys.path.append(self.openerp_dir)\n sys.path.extend([egg.location for egg in self.ws])\n from openerp.tools.config import configmanager\n configmanager(self.config_path).save()","def set_nfs_domain(session, domain, return_type=None, **kwargs):\n body_values = {'domain': domain}\n\n path = '/api/settings/nfs_domain.json'\n\n return session.post_api(path=path, body=body_values,\n return_type=return_type, **kwargs)","def default_space_settings(self) -> Optional[pulumi.Input['DomainDefaultSpaceSettingsArgs']]:\n return pulumi.get(self, \"default_space_settings\")","def domain_prompt(self):\n\n # Domain selection prompt\n domain_completer = FuzzyWordCompleter(\n list(map(str.title, DOMAINS))\n ) # Titlecase for aesthetics\n selected_domain = DOMAINS.index(\n prompt(\"Domain: \", completer=domain_completer).lower()\n )\n\n print(\"Selected Domain: {}\".format(DOMAINS[selected_domain]))\n self.domain = DOMAINS[selected_domain]\n logging.info(\"Domain Selected\")","def __init__(self, name, defaults = {} ):\n self.defaults = defaults\n self.filename = os.path.expanduser(name)+\".ini\"\n self.conf = {}\n self.reset()\n if os.path.exists(self.filename):\n self.load()","def test_defaults_overrides_with_settings(settings):\n\n settings.MARION_DOCUMENT_ISSUER_CHOICES_CLASS = (\n \"howard.documents.DocumentIssuerChoices\"\n )\n settings.MARION_DOCUMENTS_ROOT = Path(\"/tmp/documents/abc\")\n settings.MARION_DOCUMENTS_TEMPLATE_ROOT = Path(\"howard/documents/abc\")\n\n # Force module reload to take into account setting override as it is loaded\n # very early in the stack\n importlib.reload(defaults)\n\n assert (\n defaults.DOCUMENT_ISSUER_CHOICES_CLASS\n == \"howard.documents.DocumentIssuerChoices\"\n )\n assert defaults.DOCUMENTS_ROOT == Path(\"/tmp/documents/abc\")\n assert defaults.DOCUMENTS_TEMPLATE_ROOT == Path(\"howard/documents/abc\")","def _define_settings(self):\n\n self.settings = {}\n\n ##### ORIGINALLY IN THE DOMAIN FILE #######\n\n # Maximum input in the C-Space : no constituent can be more than 100% present\n self.settings['maxInp'] = 1\n\n #### ORIGINALLY IN THE SETTINGS FILE #####\n self.settings[\"epochs\"] = 3 # Training epochs\n self.settings[\"tgtStd\"] = 12e-6\n self.settings['TInit'] = 1e-6\n self.settings[\"TMin\"] = 0\n self.settings[\"TDecayRate\"] = 0.05\n self.settings[\"lambdaInit\"] = 0.011387\n self.settings['lambdaMin'] = 0.0001\n self.settings[\"lambdaDecayRate\"] = 0.60\n self.settings[\"maxSteps\"] = 300000\n self.settings[\"emaSpeedTol\"] = 0.009\n self.settings[\"emaFactor\"] = .005\n self.settings[\"printInterval\"] = 3000\n self.settings[\"summary_file\"] = \"data/summary.txt\"\n mean = torch.ones(self.grammar.bind.nF,\n self.grammar.bind.nR)/self.grammar.bind.nF\n self.settings[\"initStateMean\"] = mean\n self.settings[\"initStateStdev\"] = .025\n self.settings['clamp'] = False\n\n if self.custom_settings is not None:\n for key, value in self.custom_settings.items():\n if key in self.settings:\n self.settings[key] = value","def read_settings():\n \n settings = OrdDic()\n settings.update(json.load(open(\"resources/files/settings.txt\", \"r\")))\n\n ## OLD WAY BELOW\n\n #r = open(\"resources/files/settings.txt\", \"r\", newline=\"\\n\")\n # for option in r.read().split('\\n'):\n # try:\n # #option = option.split('\\\\')\n # #settings.update({option[0]: option[1]})\n # # settings.update(json.loads(option))\n # except IndexError:\n # pass\n return settings","def _new():\n\treturn ConfigParser(\n\tdelimiters = ('=',),\n\tcomment_prefixes = ('#', ';'),\n\tdefault_section = 'default',\n\tallow_no_value = False,\n\tstrict = False,\n\tinterpolation = ExtendedInterpolation(),\n\tdefaults = {\n\t\t'debug': False,\n\t\t'datadir': path.join(path.expanduser('~'), '.local', 'rosshm'),\n\t\t'log.level': 'warn',\n\t\t'core.enable': True,\n\t\t'db.driver': 'sqlite',\n\t\t'db.name': 'rosshmdb',\n\t\t'db.config': '',\n\t\t'static.enable': True,\n\t\t'web.enable': True,\n\t},\n)","def add_new_domain(self):\n\n domain = self.dlg.uComboBoxDomain.currentText()\n\n if domain in self.domains:\n self.dlg.uWarningSettings.show()\n self.dlg.uWarningSettings.setText(\n \"Warning: Domains must be unique. \" \"Please edit the domain below\"\n )\n return\n\n if len(self.domains) >= 10:\n self.dlg.uWarningSettings.show()\n self.dlg.uWarningSettings.setText(\n \"Warning: You can only store up to . \" \"10 domain entries\"\n )\n return\n\n if domain == \"OTHER\":\n domain = \"\"\n getattr(self.dlg, \"uTextDomain{0}\".format(len(self.domains) + 1)).setText(\n domain\n )\n getattr(self.dlg, \"uTextDomain{0}\".format(len(self.domains) + 1)).show()\n getattr(self.dlg, \"uTextAPIKey{0}\".format(len(self.domains) + 1)).show()\n getattr(self.dlg, \"uBtnRemoveDomain{0}\".format(len(self.domains) + 1)).show()\n getattr(self.dlg, \"uBtnSaveDomain{0}\".format(len(self.domains) + 1)).show()\n self.dlg.uWarningSettings.hide()","def store_domain(self, store_domain):\n self._store_domain = store_domain\n return self","def configure(prompt_list):\n darwin_vers = int(os.uname()[2].split('.')[0])\n edited_prefs = {}\n for (key, prompt) in prompt_list:\n newvalue = get_input_with_default('%15s: ' % prompt, pref(key))\n if darwin_vers == 10:\n # old behavior in SL: hitting return gives you an empty string,\n # and means accept the default value.\n edited_prefs[key] = newvalue or pref(key) or ''\n else:\n # just use the edited value as-is\n edited_prefs[key] = newvalue\n\n if FOUNDATION_SUPPORT:\n for key, value in edited_prefs.items():\n try:\n CFPreferencesSetAppValue(key, value, BUNDLE_ID)\n except BaseException:\n print('Could not save configuration!', file=sys.stderr)\n raise ConfigurationSaveError\n # remove repo_path if it exists since we don't use that\n # any longer (except for backwards compatibility) and we don't\n # want it getting out of sync with the repo_url\n CFPreferencesSetAppValue('repo_path', None, BUNDLE_ID)\n CFPreferencesAppSynchronize(BUNDLE_ID)\n\n else:\n try:\n existing_prefs = readPlist(PREFSPATH)\n existing_prefs.update(edited_prefs)\n # remove repo_path if it exists since we don't use that\n # any longer (except for backwards compatibility) and we don't\n # want it getting out of sync with the repo_url\n if 'repo_path' in existing_prefs:\n del existing_prefs['repo_path']\n writePlist(existing_prefs, PREFSPATH)\n except (IOError, OSError, ExpatError):\n print('Could not save configuration to %s' % PREFSPATH,\n file=sys.stderr)\n raise ConfigurationSaveError","def get(cls):\n try:\n return cls.objects.get(id=1)\n except cls.DoesNotExist:\n default_settings = SiteSettings(id=1)\n default_settings.save()\n return default_settings","def init(args):\n # reading existing config file, convert to configparser object\n config = config_from_file()\n config_ = configparser.ConfigParser()\n config_.add_section('osf')\n if 'username' not in config.keys():\n config_.set('osf', 'username', '')\n else:\n config_.set('osf', 'username', config['username'])\n if 'project' not in config.keys():\n config_.set('osf', 'project', '')\n else:\n config_.set('osf', 'project', config['project'])\n\n # now we can start asking for new values\n print('Provide a username for the config file [current username: {}]:'.format(\n config_.get('osf', 'username')))\n username = input()\n if username:\n config_.set('osf', 'username', username)\n\n print('Provide a project for the config file [current project: {}]:'.format(\n config_.get('osf', 'project')))\n project = input()\n if project:\n config_.set('osf', 'project', project)\n\n cfgfile = open(\".osfcli.config\", \"w\")\n config_.write(cfgfile)\n cfgfile.close()","def setDefaultSettings():\n if PLATFORM == 'Windows':\n font = 'Consolas'\n else:\n font = 'Monospace'\n\n preferenceNode = nuke.toNode('preferences')\n # viewer settings\n preferenceNode['maxPanels'].setValue(5)\n preferenceNode['TextureSize'].setValue('2048x2048')\n preferenceNode['viewer_bg_color_3D'].setValue(1280068863)\n preferenceNode['viewer_fg_color_3D'].setValue(4294967295L)\n preferenceNode['Viewer3DControlEmulation'].setValue('Maya')\n preferenceNode['middleButtonPans'].setValue(False)\n preferenceNode['dot_node_scale'].setValue(1.5)\n\n # script editor settings\n preferenceNode['clearOnSuccess'].setValue(False)\n preferenceNode['echoAllCommands'].setValue(True)\n preferenceNode['ScriptEditorFont'].setValue(font)\n preferenceNode['ScriptEditorFontSize'].setValue(12.0)\n preferenceNode['kwdsFgColour'].setValue(2629566719L)\n preferenceNode['stringLiteralsFgColourDQ'].setValue(10354943)\n preferenceNode['stringLiteralsFgColourSQ'].setValue(10354943)\n preferenceNode['commentsFgColour'].setValue(2442236415L)","def create_default_data():\n db = sh.open(the_phone_book_name, flag='n', writeback=True)\n phone_list = {'Bob': '6145617554',\n 'Leslie': '3095551212',\n 'Carol': '61455551212',\n 'Rick': '8955551212'}\n\n for name_key in phone_list:\n db[name_key] = phone_list[name_key]\n db.sync()\n db.close()","def create_settings_file():\n with open('./cfg/settings.cfg'.replace(\"/\", os.path.sep), 'w') as cfg:\n cfg.write('[report]\\nlogo = ./cfg/logo.png\\ncompany =\\nrecord =\\nunit =\\nexaminer =\\nnotes =\\n\\n[auth]\\ngmail = alias@gmail.com\\npassw = yourpassword\\ndevid = 1234567887654321\\ncelnumbr = BackupPhoneNunmber\\n\\n[app]\\npkg = com.whatsapp\\nsig = 38a0f7d505fe18fec64fbf343ecaaaf310dbd799\\n\\n[client]\\npkg = com.google.android.gms\\nsig = 38918a453d07199354f8b19af05ec6562ced5788\\nver = 9877000'.replace(\"/\", os.path.sep))","def __getSettingsFromStorage():\n return AccountSettings.getSettings(NEW_SETTINGS_COUNTER)","def __init__(self, argv: list, company: str, appname: str, Liststr=None):\n if company is None:\n company = self.__class__.__name__\n QSettings.setPath(QSettings.IniFormat, QSettings.UserScope, str(FOLDER.parent / \"settings\"))\n self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, company, appname)\n super().__init__(argv)","def test_settings_instantiation(self):\n ## no settings passed on instantiation\n bd = BorrowDirect() # no settings info\n self.assertEqual(\n True, isinstance(bd, BorrowDirect) )\n ## dict settings\n settings_dict = {} ## empty dct\n bd = BorrowDirect( settings_dict )\n self.assertEqual(\n None, bd.UNIVERSITY_CODE )\n settings_dict = { 'UNIVERSITY_CODE': '123' } ## populated dct\n bd = BorrowDirect( settings_dict )\n self.assertEqual(\n '123', bd.UNIVERSITY_CODE )\n ## module settings\n s = imp.new_module( 'settings' ) ## empty module\n bd = BorrowDirect( s )\n self.assertEqual(\n None, bd.UNIVERSITY_CODE )\n s = imp.new_module( 'settings' ) ## populated module\n s.UNIVERSITY_CODE = '234'\n bd = BorrowDirect( s )\n self.assertEqual(\n '234', bd.UNIVERSITY_CODE )","def get_pref(self, key, domain=BUNDLE_ID):\n value = CFPreferencesCopyAppValue(key, domain) or None\n # Casting NSArrays and NSDictionaries to native Python types.\n # This a workaround for 10.6, where PyObjC doesn't seem to\n # support as many common operations such as list concatenation\n # between Python and ObjC objects.\n if isinstance(value, NSArray):\n value = list(value)\n elif isinstance(value, NSDictionary):\n value = dict(value)\n return value","def domain(self, domain):\n self._domain = domain","def domain(self, domain):\n self._domain = domain","def default_space_settings(self) -> pulumi.Output[Optional['outputs.DomainDefaultSpaceSettings']]:\n return pulumi.get(self, \"default_space_settings\")","def get_pref(key, domain=BUNDLE_ID):\n if CFPreferencesCopyAppValue(key, domain):\n return CFPreferencesCopyAppValue(key, domain)\n return None","def load_default_space_and_org(self):\n try:\n space_url = self.lookup_cf_response(\"default_space_url\")\n except AttributeError:\n return\n space = self._fetcher.get_entities(space_url)\n if 'organization_url' in space:\n org_url = space['organization_url']\n org = self._fetcher.get_entities(org_url)\n\n if ('name' in space) and ('name' in org):\n self._default_organization = org['name']\n self._default_space = space['name']","def site(self, domain):\r\n return resource.Site(self, domain)","def pref(pref_name):\n default_prefs = {\n 'ServerURL': 'http://munkiwebadmin',\n 'authKey': '',\n }\n pref_value = CFPreferencesCopyAppValue(pref_name, BUNDLE_ID)\n if pref_value is None:\n pref_value = default_prefs.get(pref_name)\n # we're using a default value. We'll write it out to\n # /Library/Preferences/<BUNDLE_ID>.plist for admin\n # discoverability\n set_pref(pref_name, pref_value)\n if isinstance(pref_value, NSDate):\n # convert NSDate/CFDates to strings\n pref_value = str(pref_value)\n return pref_value","def read_settings(self):\n self.settings = read_settings(self.settings_path)","def setPreferencesAtStartup(self):\n\t\tif os.path.isfile(self.userPrefsFileName):\n\t\t\tprefs = open(self.userPrefsFileName, 'r')\n\t\t\tprefsLine = prefs.readline()\n\t\t\tprefs.close()\n\t\t\t\n\t\t\tfor i in range(0,len(prefsLine)):\n\t\t\t\tc = prefsLine[i]\n\t\t\t\tif c is not \"/\":\n\t\t\t\t\tself.setPreference(c)\n\t\t\t\telse:\n\t\t\t\t\tself.setPreference(prefsLine[i:])\n\t\t\t\t\tbreak","def setupDefaultProperties( self, p, id, title, description, email_from_address, email_from_name,\n validate_email, server_url, stemmer ):\n p._setProperty( 'email_from_address', email_from_address, 'string' )\n p._setProperty( 'email_from_name', email_from_name, 'string' )\n p._setProperty( 'validate_email', validate_email and 1 or 0, 'boolean' )\n p._setProperty( 'email_antispam', '', 'string' )\n p._setProperty( 'email_error_address', '', 'string' )\n p._setProperty( 'instance', id, 'string' )\n p._setProperty( 'remote_url', '', 'string' )\n\n p._setProperty( 'apply_threading', 1, 'boolean' )\n p._setProperty( 'use_timeout', 1, 'boolean' )\n p._setProperty( 'duration', 0.001, 'float' )\n p._setProperty( 'p_resolve_conflict', 0, 'boolean' )\n\n p._setProperty( 'max_involved_users', 10, 'int' )\n p._setProperty( 'service_timeout', 30, 'int' )\n p._setProperty( 'created_search_interval', 999, 'int' )\n p._setProperty( 'common_url', '', 'string' )\n\n p._setProperty( 'send_to_support', 0, 'boolean' )\n p._setProperty( 'member_activity', 1, 'boolean' )\n p._setProperty( 'emergency_service', 0, 'boolean' )\n p._setProperty( 'p_log', 0, 'boolean' )\n\n p._setProperty( 'suspended_mail', 1, 'boolean' )\n p._setProperty( 'mail_frequency', 1, 'int' )\n p._setProperty( 'mail_threshold', 500, 'int' )\n\n p._setPropValue( 'server_url', server_url )\n p._setPropValue( 'stemmer', stemmer )\n\n p.title = title\n p.description = description","def create_default_config(self, parser):\n parser.add_section('irc')\n parser.set('irc', 'channels', '')\n \n # create the full path, and the file\n try:\n os.makedirs(self.config_dir_path, mode=0700)\n except OSError:\n pass\n file_resource = open(self.config_file_path, 'w')\n parser.write(file_resource)","def fromenv(cls) -> 'Config':\n files = Config.find_config_files()\n if not files:\n log.info(\n \"Could not find default config: `~/.wpwatcher/wpwatcher.conf`, `~/wpwatcher.conf` or `./wpwatcher.conf`\"\n )\n return cls.default()\n else:\n return cls.fromfiles(files)","def create_domain_name(self, DomainName: str, DomainNameConfigurations: List = None) -> Dict:\n pass","def __init__(self):\n super(sppasPathSettings, self).__init__()\n\n sppas_dir = os.path.dirname(os.path.dirname(\n os.path.dirname(os.path.abspath(__file__))))\n\n self.__dict__ = dict(\n sppas=sppas_dir,\n cli=os.path.join(sppas_dir, \"bin\"),\n etc=os.path.join(sppas_dir, \"etc\"),\n po=os.path.join(sppas_dir, \"po\"),\n src=os.path.join(sppas_dir, \"src\"),\n plugins=os.path.join(os.path.dirname(sppas_dir), \"plugins\"),\n resources=os.path.join(os.path.dirname(sppas_dir), \"resources\"),\n samples=os.path.join(os.path.dirname(sppas_dir), \"samples\"),\n logs=os.path.join(os.path.dirname(sppas_dir), \".logs\"),\n wkps=os.path.join(os.path.dirname(sppas_dir), \"workspaces\"),\n trash=os.path.join(os.path.dirname(sppas_dir), \".trash\"),\n )","def create_domain(domain_id, default_role):\n tx = iroha.transaction(\n [iroha.command(\"CreateDomain\", domain_id=domain_id, default_role=\"user\")]\n )\n ic.sign_transaction(tx, user_private_key)\n send_transaction_print_status_and_return_result(tx)","def add_local_settings():\n put('/Users/peter/Dropbox/Projects/ChromeFiddle/Local\\ Settings/prod/local_settings.py', \n '/home/django/web/chromefiddle/chromefiddle/settings')","def loadDefaults(self):\n # (025) Merged into settings.RawSettings.\n pass","def test_domain(self):\n self.assertEqual(self.gmail_case.domain, 'google.com')\n self.gmail_case.domain = 'yahoo.com'\n self.assertEqual(self.gmail_case.domain, 'yahoo.com')\n self.assertEqual(self.sld_case.domain, 'amazon.co.uk')\n self.assertEqual(self.gmail_case.tld, 'com')\n self.assertEqual(self.sld_case.tld, 'co.uk')\n self.gmail_case.tld = 'co.ke'\n self.sld_case.tld = 'gov'\n self.assertEqual(self.gmail_case.tld, 'co.ke')\n self.assertEqual(self.sld_case.tld, 'gov')\n self.assertEqual(self.gmail_case.domain, 'yahoo.co.ke')\n self.assertEqual(self.sld_case.domain, 'amazon.gov')","def auth_domain(request):\n return request.registry.settings.get('h.auth_domain', request.domain)","def load_preferences(self):\n\n print 'Loading current DNAtool preferences'\n self.preferences = Preferences('DNAtool',{'canvas_height':600})\n\n for key in self.defaultprefs:\n if key in self.preferences.prefs:\n self.__dict__[key].set(self.preferences.get(key))\n else:\n self.preferences.set(key, self.defaultprefs[key])\n\n self.update_window_formatting()\n return","def settings():\n return _get_settings()[1]","def return_domain_values(hostname, domain_name, username):\n myconnection = ssh_connection(hostname, username)\n if myconnection == 1:\n return \"Connection to %s failed\" % hostname\n else:\n #If the user want the defaults values\n if domain_name == \"default\":\n list = []\n #Get the default destination\n stdin, stdout, stderr = myconnection.exec_command(\"/bin/cat /etc/postfix/main.cf | grep default_destination | cut -d '=' -f 2\" )\n out=stdout.read().splitlines()\n else:\n # Send the command (non-blocking)\n commandline=\"/bin/cat /etc/postfix/main.cf | grep %s | cut -d '=' -f 2\" % (domain_name)\n stdin, stdout, stderr = myconnection.exec_command(commandline)\n\n #On récupère la sortie standard\n out=stdout.read().splitlines()\n\n if not out:\n # Disconnect from the host\n myconnection.close()\n return \"No value for this domain. Are you sure this domain exist ?\"\n exit(1)\n else:\n # Disconnect from the host\n myconnection.close()\n #On retourne la liste des domaines\n return out","def domain_profile(self, domain):\n return self.apiquery('/v1/{}'.format(domain))","def _update_site_configuration(self):\n self.site.configuration.site_values = {'THIRD_PARTY_AUTH_ONLY_DOMAIN': self.email_domain_name}\n self.site.configuration.save()","def readSettings(self):\n settings = QtCore.QSettings()\n # defaults to the current directory path\n current_dir_abspath = os.path.abspath('')\n defaultValue = QtCore.QString(current_dir_abspath)\n # Warning:\n # QSettings.value can return different types (QVariant types) depending on the platform it's running on,\n # so the safest way to use it is always casting the result to the desired type, e.g.: int(settings.value(\"myKey\")).\n output_directory = settings.value(\"output_directory\", defaultValue=defaultValue).toString()\n self.ui.outputDirLineEdit.setText(output_directory)"],"string":"[\n \"def settings_create(ctx):\\n # Choose where and whether to save the configuration file.\\n path = ctx.obj['load_path']\\n if path:\\n click.confirm(\\n 'A settings file already exists. Continuing will override it. '\\n 'Do you want to continue?',\\n abort=True,\\n )\\n else:\\n path = ctx.obj['save_path']\\n\\n # Get information about Pulp.\\n pulp_config = {'pulp': _get_pulp_properties()}\\n pulp_config['hosts'] = [\\n _get_host_properties(pulp_config['pulp']['version'])\\n ]\\n pulp_config['pulp']['version'] = str(pulp_config['pulp']['version'])\\n try:\\n config.validate_config(pulp_config) # This should NEVER fail!\\n except exceptions.ConfigValidationError:\\n print(\\n 'An internal error has occurred. Please report this to the Pulp '\\n 'Smash developers at https://github.com/PulpQE/pulp-smash/issues',\\n file=sys.stderr,\\n )\\n raise\\n\\n # Write the config to disk.\\n with open(path, 'w') as handler:\\n handler.write(json.dumps(pulp_config, indent=2, sort_keys=True))\\n click.echo('Settings written to {}.'.format(path))\",\n \"def open_settings(location, show_defaults=False, settings_type=None, **kwargs):\\n prefs = kwargs.get('prefs', settings.InternalSettings())\\n if settings_type:\\n settings_type = settings_type.lower()\\n\\n target_path = prefs.get_settings_path(location, settings_type)\\n if not target_path.exists():\\n dirname = target_path.parent\\n makedirs(dirname, mode=0o775, exist_ok=True)\\n with open(target_path, 'a', newline='\\\\n') as settings_file:\\n settings_file.write('{}')\\n\\n if show_defaults:\\n openable = [prefs.get_settings_path('default', settings_type, target_path.suffix), target_path]\\n else:\\n openable = [target_path]\\n return result.Success(openable=openable)\",\n \"def load_settings_from_cli():\\n load_user_from_cli()\\n load_local_contacts()\",\n \"def loadSettings(home_dir,pd_dir):\\n\\n settingsXML = os.path.join(pd_dir,\\\"settings.xml\\\")\\n\\n #print(\\\"Loading settings from {0}\\\".format(settingsXML))\\n\\n global installationTree\\n global installationSettings\\n global domainPath\\n global userEmail\\n global userToken\\n\\n if os.path.isfile(settingsXML):\\n installationTree = etree.parse(settingsXML)\\n installationSettings = installationTree.getroot()\\n\\n for child in installationSettings:\\n if child.tag == \\\"domain_path\\\":\\n domainPath = child.text\\n\\n if not os.path.isdir(domainPath):\\n fetchPlanningDomains(domainPath)\\n\\n if child.tag == \\\"email\\\":\\n userEmail = child.text\\n\\n if child.tag == \\\"token\\\":\\n userToken = child.text\\n\\n return\\n\\n if installationSettings is None:\\n installationSettings = etree.Element(\\\"{http://settings.planning.domains}settings\\\")\\n installationTree = etree.ElementTree(installationSettings)\\n\\n domainPath = input(\\\"Enter path for installing files (or hit enter to use {0}): \\\".format(os.path.join(home_dir,\\\"planning.domains\\\")))\\n\\n domainPath = domainPath.lstrip()\\n domainpath = domainPath.rstrip()\\n\\n if domainPath == \\\"\\\":\\n domainPath = os.path.join(home_dir,\\\"planning.domains\\\")\\n\\n if os.path.isfile(domainPath):\\n print(\\\"Fatal error: there is already a file called {0}\\\".format(domainPath))\\n exit(1)\\n\\n if not os.path.isdir(domainPath):\\n fetchPlanningDomains(domainPath)\\n\\n etree.SubElement(installationSettings,\\\"domain_path\\\").text = domainPath\\n\\n userEmail = input(\\\"Enter email for API updates: \\\")\\n userToken = input(\\\"Enter token for API updates (leave blank if none provided): \\\")\\n\\n etree.SubElement(installationSettings,\\\"email\\\").text = userEmail\\n etree.SubElement(installationSettings,\\\"token\\\").text = userToken\\n\\n saveSettings()\",\n \"def set_by_domain(domain):\\r\\n if not has_configuration_set() or not domain:\\r\\n return\\r\\n\\r\\n for key, value in settings.MICROSITE_CONFIGURATION.items():\\r\\n subdomain = value.get('domain_prefix')\\r\\n if subdomain and domain.startswith(subdomain):\\r\\n _set_current_microsite(key, subdomain, domain)\\r\\n return\\r\\n\\r\\n # if no match on subdomain then see if there is a 'default' microsite defined\\r\\n # if so, then use that\\r\\n if 'default' in settings.MICROSITE_CONFIGURATION:\\r\\n _set_current_microsite('default', subdomain, domain)\",\n \"def make_pref_file():\\r\\n pref_dict = {\\\"default_user\\\": None}\\r\\n\\r\\n with open(os.path.join(os.path.dirname(__file__), \\\"preferences.json\\\"), \\\"w\\\") as pref:\\r\\n pref.write(json.dumps(pref_dict, indent=4))\\r\\n\\r\\n return pref_dict\",\n \"def create_domain(self, domain: str) -> Session:\\n uri = f\\\"{self.uri}/domains\\\"\\n data = {\\n \\\"hostname\\\": domain\\n }\\n response = self.request(uri=uri, method=\\\"POST\\\", data=data)\\n\\n return response\",\n \"def create_default_settings():\\n from flaskbb.fixtures.settings import fixture\\n create_settings_from_fixture(fixture)\",\n \"def make_settings(pypirc):\\n default_pypirc = \\\"\\\"\\\"\\n [pypi]\\n username:foo\\n password:bar\\n \\\"\\\"\\\"\\n\\n def _settings(pypirc_text=default_pypirc, **settings_kwargs):\\n pypirc.write(textwrap.dedent(pypirc_text))\\n\\n settings_kwargs.setdefault(\\\"sign_with\\\", None)\\n settings_kwargs.setdefault(\\\"config_file\\\", str(pypirc))\\n\\n return settings.Settings(**settings_kwargs)\\n\\n return _settings\",\n \"def load_settings(self):\\n\\n self.domains = []\\n self.clear_settings()\\n api_keys = self.api_key_instance.get_api_keys()\\n if api_keys:\\n for domain, api_key in list(api_keys.items()):\\n self.domains.append(domain)\\n getattr(self.dlg, \\\"uTextDomain{0}\\\".format(len(self.domains))).setText(\\n domain\\n )\\n getattr(self.dlg, \\\"uTextAPIKey{0}\\\".format(len(self.domains))).setText(\\n api_key\\n )\\n\\n # Hide un-populated domain rows\\n for entry in range(len(self.domains) + 1, 11):\\n getattr(self.dlg, \\\"uTextDomain{0}\\\".format(entry)).hide()\\n getattr(self.dlg, \\\"uTextAPIKey{0}\\\".format(entry)).hide()\\n getattr(self.dlg, \\\"uBtnRemoveDomain{0}\\\".format(entry)).hide()\\n getattr(self.dlg, \\\"uBtnSaveDomain{0}\\\".format(entry)).hide()\",\n \"def create_domain(DomainName=None):\\n pass\",\n \"def get_domain_config():\\n query = {\\n \\\"type\\\": \\\"config\\\",\\n \\\"action\\\": \\\"get\\\",\\n \\\"xpath\\\": \\\"/config/devices/entry[@name='localhost.localdomain']/deviceconfig/system/domain\\\",\\n }\\n\\n return __proxy__[\\\"panos.call\\\"](query)\",\n \"def populate_domain_data(self, domain):\\n self.domain_resolve(domain)\\n domain_data = server.get_domain_data(domain)['data']['userdata']\\n\\n self.domain_data[domain] = self.domain_resolve(domain)\\n\\n if domain in self.domain_data.keys():\\n try:\\n self.domain_data[domain]['documentroot'] = domain_data['documentroot']\\n self.domain_data[domain]['ip'] = domain_data['ip']\\n except KeyError:\\n self.domain_data[domain]['documentroot'] = \\\"No domain data found, admin should check\\\"\\n self.domain_data[domain]['ip'] = \\\"No domain data found, admin should check\\\"\",\n \"def get_domain_config(self, defaultcfg, wireframe):\\n\\n dnsdata = dnslib.DNSRecord.parse(wireframe)\\n dnsdomain = dnsdata.q.get_qname()\\n\\n for ruleset in globals.config.rules.match:\\n if re.search(str(ruleset.domain), str(dnsdomain)):\\n # domain config matches!\\n return Box({**defaultcfg, **ruleset})\\n\\n return defaultcfg\",\n \"def __init__(__self__, *,\\n domain: pulumi.Input[str]):\\n pulumi.set(__self__, \\\"domain\\\", domain)\",\n \"def __init__(__self__, *,\\n domain: pulumi.Input[str]):\\n pulumi.set(__self__, \\\"domain\\\", domain)\",\n \"def loadSettings():\\r\\n try:\\r\\n settingsFile = open(sys.argv[1], \\\"r\\\")\\r\\n except IOError:\\r\\n logging.exception(\\\"Error opening settings.\\\")\\r\\n exitApp()\\r\\n \\r\\n settingStr = settingsFile.read()\\r\\n settingsFile.close()\\r\\n \\r\\n try:\\r\\n settings = json.loads(settingStr)\\r\\n except ValueError:\\r\\n logging.exception(\\\"Error parsing settings.\\\")\\r\\n exitApp()\\r\\n \\r\\n # Check integrity\\r\\n if (len(settings[\\\"reddit_username\\\"]) == 0):\\r\\n logging.critical(\\\"Reddit username not set.\\\")\\r\\n exitApp()\\r\\n \\r\\n if (len(settings[\\\"reddit_password\\\"]) == 0):\\r\\n logging.critical(\\\"Reddit password not set.\\\")\\r\\n exitApp()\\r\\n \\r\\n if (len(settings[\\\"reddit_subreddit\\\"]) == 0):\\r\\n logging.critical(\\\"Subreddit not set.\\\")\\r\\n exitApp()\\r\\n \\r\\n if (len(settings[\\\"reddit_ua\\\"]) == 0):\\r\\n logging.critical(\\\"Reddit bot user agent not set.\\\")\\r\\n exitApp()\\r\\n \\r\\n settings[\\\"repost_protection\\\"] = bool(settings[\\\"repost_protection\\\"])\\r\\n \\r\\n return settings\",\n \"def default_user_settings(self) -> pulumi.Input['DomainUserSettingsArgs']:\\n return pulumi.get(self, \\\"default_user_settings\\\")\",\n \"def load_from_defaults(self):\\n default_settings = import_module('mindinsight.conf.defaults')\\n for setting in dir(default_settings):\\n if setting.isupper():\\n setattr(self, setting, getattr(default_settings, setting))\\n self._default_settings.add(setting)\",\n \"def create_default_config():\\n import codecs\\n config = ConfigParser.SafeConfigParser()\\n config.readfp(StringIO(DEFAULT_CONFIG))\\n\\n # Load user settings\\n filename = get_user_config_filename()\\n if not os.path.exists(filename):\\n from wizard import setup_wizard\\n setup_wizard(config)\\n else:\\n try:\\n fi = codecs.open(filename, 'r', encoding='utf-8')\\n config.readfp(fi)\\n finally:\\n fi.close()\\n return config\",\n \"def generate_settings():\\r\\n conf_file = os.path.join(os.path.dirname(base_settings.__file__),\\r\\n 'example', 'conf.py')\\r\\n conf_template = open(conf_file).read()\\r\\n default_url = 'http://salmon.example.com'\\r\\n site_url = raw_input(\\\"What will be the URL for Salmon? [{0}]\\\".format(\\r\\n default_url))\\r\\n site_url = site_url or default_url\\r\\n secret_key = base64.b64encode(os.urandom(KEY_LENGTH))\\r\\n api_key = base64.b64encode(os.urandom(KEY_LENGTH))\\r\\n output = conf_template.format(api_key=api_key, secret_key=secret_key,\\r\\n site_url=site_url)\\r\\n return output\",\n \"def set_domain(domain):\\n set_hosts(domain)\\n click.echo(\\n 'Host file was set: {} -> 127.0.0.1'.format(', '.join(domain))\\n )\",\n \"def setup_domain(domain):\\n bucket = BUCKET_MANAGER.get_bucket(domain)\\n\\n zone = DOMAIN_MANAGER.find_hosted_zone(domain) \\\\\\n or DOMAIN_MANAGER.create_hosted_zone(domain)\\n\\n endpoint = util.get_endpoint(BUCKET_MANAGER.get_region_name(bucket))\\n a_record = DOMAIN_MANAGER.create_s3_domain_record(zone, domain, endpoint)\\n print(\\\"Domain configure: http://{}\\\".format(domain))\\n print(\\\"A record created: {}\\\".format(a_record))\",\n \"def init_settings(self):\\n if not os.path.exists(self.settingsFilePath):\\n settings_dir = os.getenv(\\\"APPDATA\\\") + \\\"\\\\\\\\\\\" + qApp.applicationName()\\n if not os.path.exists(settings_dir):\\n os.makedirs(settings_dir)\\n setting_path = \\\"\\\"\\n if getattr(sys, 'frozen', False):\\n setting_path = os.path.dirname(sys.executable)\\n elif __file__:\\n setting_path = os.path.dirname(__file__)\\n shutil.copyfile(os.path.join(setting_path, \\\"resources\\\\eksettings.ini\\\"), self.settingsFilePath)\\n return\",\n \"def findSettingsFile():\\n settingsName = 'oct-fire-settings.json'\\n userPath = os.path.expanduser('~')\\n if os.path.exists(settingsName):\\n return settingsName\\n elif os.path.exists(os.path.join(userPath, settingsName)):\\n return os.path.join(userPath, settingsName)\\n elif os.path.exists(os.path.join(userPath, 'Desktop', settingsName)):\\n return os.path.join(userPath, 'Desktop', settingsName)\\n elif os.path.exists(os.path.join(userPath, 'Documents', settingsName)):\\n return os.path.join(userPath, 'Documents', settingsName)\\n elif os.path.exists(os.path.join(userPath, 'Downloads', settingsName)):\\n return os.path.join(userPath, 'Downloads', settingsName)\\n raise Exception('Could not locate settings file')\",\n \"def ini(filename, **defaults):\\n filename = sh.path(filename)\\n defaults.update(home=sh.path('~'))\\n return ConfigObject(filename=filename, defaults=defaults)\",\n \"def __init__(self, settings, valid, defaults=None):\\n\\n try:\\n with open(settings, 'r') as settings_file:\\n self._settings = json.load(settings_file)\\n except TypeError:\\n self._settings = dict(settings)\\n self._settings = Settings._inject_defaults(self._settings, defaults)\\n Settings._validity_check(self._settings, valid)\",\n \"def getDefaultSettings(self) -> ghidra.docking.settings.Settings:\\n ...\",\n \"def set_domain_path(self):\\n\\n self.domain_path = os.path.join(self.docs_path, self.domain)\\n if not os.path.exists(self.domain_path):\\n os.makedirs(self.domain_path)\",\n \"def settings() -> Settings:\\n return Settings()\",\n \"def load_settings(self):\\n\\n self.std = settings.settings\",\n \"def pref(pref_name):\\n default_prefs = {\\n 'ServerURL': 'http://sal',\\n }\\n pref_value = CFPreferencesCopyAppValue(pref_name, BUNDLE_ID)\\n if pref_value == None:\\n pref_value = default_prefs.get(pref_name)\\n # we're using a default value. We'll write it out to\\n # /Library/Preferences/<BUNDLE_ID>.plist for admin\\n # discoverability\\n set_pref(pref_name, pref_value)\\n if isinstance(pref_value, NSDate):\\n # convert NSDate/CFDates to strings\\n pref_value = str(pref_value)\\n return pref_value\",\n \"def from_settings(settings):\",\n \"def load_settings(self, outfile='settings.p'):\\n settings = pickle.load(open(path,'rb'))\\n self.__dict__.update(settings)\",\n \"def set_domain(self, var, domain) :\\n if var not in self.variables :\\n raise KeyError(str(var) + \\\" is not a variable in this problem.\\\")\\n self.domains[var] = sorted(domain[:])\\n return self\",\n \"def get_settings(hostname: Optional[str] = None, device_type: Optional[DeviceType] = None):\\n with open('/etc/cnaas-nms/repository.yml', 'r') as repo_file:\\n repo_config = yaml.safe_load(repo_file)\\n\\n local_repo_path = repo_config['settings_local']\\n try:\\n verify_dir_structure(local_repo_path, DIR_STRUCTURE)\\n except VerifyPathException as e:\\n logger.exception(\\\"Exception when verifying settings repository directory structure\\\")\\n raise e\\n\\n # 1. Get CNaaS-NMS default settings\\n data_dir = pkg_resources.resource_filename(__name__, 'data')\\n with open(os.path.join(data_dir, 'default_settings.yml'), 'r') as f_default_settings:\\n settings: dict = yaml.safe_load(f_default_settings)\\n\\n settings_origin = {}\\n for k in settings.keys():\\n settings_origin[k] = 'default'\\n\\n # 2. Get settings repo global settings\\n settings, settings_origin = read_settings(\\n local_repo_path, ['global', 'base_system.yml'], 'global', settings, settings_origin)\\n # 3. Get settings from special fabric classification (dist + core)\\n if device_type and (device_type == DeviceType.DIST or device_type == DeviceType.CORE):\\n settings, settings_origin = read_settings(\\n local_repo_path, ['fabric', 'base_system.yml'], 'fabric',\\n settings, settings_origin)\\n # 4. Get settings repo device type settings\\n if device_type:\\n settings, settings_origin = read_settings(\\n local_repo_path, [device_type.name.lower(), 'base_system.yml'], 'devicetype',\\n settings, settings_origin)\\n # 5. Get settings repo device specific settings\\n if hostname:\\n if os.path.isdir(os.path.join(local_repo_path, 'devices', hostname)):\\n settings, settings_origin = read_settings(\\n local_repo_path, ['devices', hostname, 'base_system.yml'], 'device',\\n settings, settings_origin)\\n # Verify syntax\\n check_settings_syntax(settings, settings_origin)\\n return f_root(**settings).dict(), settings_origin\",\n \"def setup_settings():\\n # pylint: disable=import-outside-toplevel\\n from django.conf import settings\\n import tiny_erp.settings as defaults\\n\\n for name in dir(defaults):\\n if name.isupper() and not hasattr(settings, name):\\n setattr(settings, name, getattr(defaults, name))\",\n \"def get_preferred_domain(project=None, default_to_appid=True):\\n projects_prefs = settings.PREFERRED_DOMAIN_NAMES.get(settings.APP_ID, {})\\n preferred_domain = projects_prefs.get(project)\\n if not preferred_domain:\\n preferred_domain = projects_prefs.get(None)\\n if not preferred_domain:\\n if default_to_appid:\\n preferred_domain = '%s.appspot.com' % app_identity.get_application_id()\\n return preferred_domain\",\n \"def defaultConf():\\n from config import lwbdUrl, userAndPass\\n baseUrl = lwbdUrl\\n lucidAuth = userAndPass\\n return LucidSdaConfiguration(baseUrl,\\n lucidAuth)\",\n \"def setPreference(self, newPreference):\\n\\t\\tif newPreference == \\\"d\\\":\\n\\t\\t\\tself.showDomains = 1\\n\\t\\telif newPreference == \\\"w\\\":\\n\\t\\t\\tself.showDomains = 0\\n\\t\\telif newPreference == \\\"l\\\":\\n\\t\\t\\tself.showFullTitles = 1\\n\\t\\telif newPreference == \\\"o\\\":\\n\\t\\t\\tself.showFullTitles = 0\\n\\t\\telif newPreference == \\\"c\\\":\\n\\t\\t\\tself.collapseOldStories = 1\\n\\t\\telif newPreference == \\\"e\\\":\\n\\t\\t\\tself.collapseOldStories = 0\\n\\t\\telif newPreference[0] == \\\"/\\\":\\n\\t\\t\\tself.hnUserName = newPreference[1:]\\n\\n\\t\\twriteWentWell = self.writePreferenceToFile(newPreference)\\n\\t\\tif not writeWentWell:\\n\\t\\t\\tinput = raw_input(\\\"hnsh_prefs.txt not found. Preferences changed will only be kept until this program is closed. Press Return to continue. \\\")\",\n \"def find_settings():\\n return Setting()\",\n \"def default_settings(self, settings):\\n return {}\",\n \"def default_user_settings(self) -> pulumi.Output['outputs.DomainUserSettings']:\\n return pulumi.get(self, \\\"default_user_settings\\\")\",\n \"def getDefaultSettings():\\n return {}\",\n \"def __init__(self, bot, name, default_settings=None):\\n if default_settings is None:\\n default_settings = {}\\n self.bot = bot\\n self.name = name\\n self.default_settings = default_settings\\n\\n # set up storage for settings and load from persistent file\\n self.settings_path = pathlib.Path(\\\".settings\\\", f\\\"{self.name}.yml\\\")\\n self.id_dict = load_persistent_settings(self.settings_path)\",\n \"def __init__(self, location=None, default_location=None):\\n RawConfigParser.__init__(self)\\n\\n self.location = location\\n self._saving = False\\n self._dirty = False\\n\\n if default_location is not None:\\n try:\\n self.read(default_location)\\n except:\\n pass\\n\\n if location is not None:\\n try:\\n self.read(self.location) or \\\\\\n self.read(self.location + \\\".new\\\") or \\\\\\n self.read(self.location + \\\".old\\\")\\n except:\\n pass\\n\\n if self.get_option('settings/version', 0) is None:\\n self.set_option('settings/version', self.__version__)\",\n \"def __init__(self):\\n for name, default in self.defaults.items():\\n value = getattr(django.conf.settings, name, default)\\n setattr(self, name, value)\",\n \"def create_settings(root_directory, files, variables, main_file, output):\\n\\tfiles = [format_path(f) for f in files]\\n\\tvariables = format_variables(variables)\\n\\tsettings = {\\n\\t\\tSETTINGS_ROOTDIR : root_directory if root_directory.endswith('/') else root_directory+'/',\\n\\t\\tSETTINGS_FILES : files,\\n\\t\\tSETTINGS_VARIABLES : variables,\\n\\t\\tSETTINGS_MAIN : format_path(main_file),\\n\\t\\tSETTINGS_OUTPUT : output + SETTINGS_OUTPUT_PATH\\n\\t}\\n\\treturn settings\",\n \"def save_domain(self):\\n del_domain = 0\\n save_domain = 0\\n\\n sending_btn = self.dlg.sender().objectName()\\n if sending_btn[:-1] == \\\"uBtnRemoveDomain\\\":\\n del_domain = sending_btn[-1]\\n if sending_btn[:-1] == \\\"uBtnSaveDomain\\\":\\n save_domain = sending_btn[-1]\\n\\n keys = {}\\n for entry in range(1, len(self.domains) + 2):\\n if int(del_domain) == entry:\\n continue\\n domain = getattr(self.dlg, \\\"uTextDomain{0}\\\".format(entry)).text()\\n key = getattr(self.dlg, \\\"uTextAPIKey{0}\\\".format(entry)).text().strip()\\n if domain and key:\\n keys[domain] = key\\n self.api_key_instance.set_api_keys(keys)\\n\\n # remove store capability docs for the removed or add domain/key\\n # if they already exits .i.e these will be reloaded\\n if save_domain:\\n ui_elem_num = save_domain\\n else:\\n ui_elem_num = del_domain\\n\\n domain = getattr(self.dlg, \\\"uTextDomain{0}\\\".format(ui_elem_num)).text()\\n self.local_store.del_domains_xml(domain)\\n\\n # load / Reload service data\\n self.load_settings()\\n self.dlg.uWarningSettings.hide()\\n self.dlg.uLabelWarning.hide()\\n if self.curr_list_wid_index is not None:\\n self.dlg.uListOptions.setCurrentItem(self.curr_list_wid_index)\\n else:\\n self.dlg.uListOptions.setCurrentRow(0)\\n\\n self.dlg.uStackedWidget.setCurrentIndex(0)\\n self.services_loaded = False # key change, load data again\\n self.load_ui()\",\n \"def default(cls) -> 'Config':\\n parser: configparser.ConfigParser = configparser.ConfigParser()\\n parser.read_dict(dict(wpwatcher=Config.DEFAULT_CONFIG))\\n return cls.fromparser(parser)\",\n \"def get_defaults():\\r\\n profile = settings.profile_manager.get(\\\"default\\\")\\r\\n config = profile.get_config('freeseer.conf', settings.FreeseerConfig, storage_args=['Global'], read_only=True)\\r\\n return {\\r\\n \\\"video_directory\\\": config.videodir,\\r\\n \\\"oauth2_token\\\": os.path.join(settings.configdir, \\\"oauth2_token.json\\\"),\\r\\n \\\"client_secrets\\\": os.path.join(settings.configdir, \\\"client_secrets.json\\\")\\r\\n }\",\n \"def get_defaults():\\n\\n # get package defaults\\n with open(os.path.join(iLoop_RNAseq_pipeline.__path__[0], 'defaults', 'RNAseq_pipeline_defaults.txt')) as rpd:\\n defaults = {}\\n for line in rpd.readlines():\\n if line.strip():\\n defaults[line.split(',')[0].strip()] = line.split(',')[1].strip()\\n\\n try:\\n with open(os.path.join(os.path.expanduser(\\\"~\\\"), 'RNAseq_pipeline_defaults.txt')) as rpd:\\n for line in rpd.readlines():\\n if line.strip():\\n defaults[line.split(',')[0].strip()] = line.split(',')[1].strip()\\n except FileNotFoundError:\\n logger.warning('\\\"RNAseq_pipeline_defaults.txt\\\" does not exist under home path. An email address and project ID should be should be define in that file.')\\n\\n # replace with user defaults\\n try:\\n with open('RNAseq_pipeline_defaults.txt') as rpd:\\n for line in rpd.readlines():\\n if line.strip():\\n defaults[line.split(',')[0].strip()] = line.split(',')[1].strip()\\n except FileNotFoundError:\\n logger.info(\\n '\\\"RNAseq_pipeline_defaults.txt\\\" does not exist under this folder. Defaults from the package and home path will be used.')\\n\\n if 'email' not in defaults:\\n if not validate_email(defaults['email']):\\n while True:\\n email = input('Enter a valid email address for job status: \\\\n')\\n if validate_email(email):\\n defaults['email'] = email\\n print('Writing email to \\\"RNAseq_pipeline_defaults.txt\\\" under home path.')\\n f = open(os.path.join(os.path.expanduser(\\\"~\\\"), 'RNAseq_pipeline_defaults.txt'), 'w+')\\n f.write('\\\\nemail,{}'.format(email))\\n f.close()\\n break\\n else:\\n print('{} is not valid, try again.'.format(email))\\n\\n if ('project' not in defaults) or (defaults['project'] == 'projectid'):\\n project = input('Enter Computerome project ID for billing: \\\\n')\\n # TODO It is possible to validate this by checking folder name under \\\"/home/projects\\\".\\n defaults['project'] = project\\n print('Writing project ID to \\\"RNAseq_pipeline_defaults.txt\\\" under home path.')\\n f = open(os.path.join(os.path.expanduser(\\\"~\\\"), 'RNAseq_pipeline_defaults.txt'), 'w+')\\n f.write('\\\\nproject,{}'.format(project))\\n f.close()\\n\\n return defaults\",\n \"def initialize_settings(tool_name, source_path, dest_file_name=None):\\n settings_dir = os.path.join(SETTINGS_DIRECTORY, tool_name)\\n if not os.path.exists(settings_dir):\\n os.mkdir(settings_dir)\\n if not dest_file_name:\\n dest_file_name = os.path.basename(source_path)\\n settings_path = os.path.join(settings_dir, dest_file_name)\\n if not os.path.exists(settings_path):\\n shutil.copy(source_path, settings_path)\\n else:\\n try:\\n SettingsMigrator(source_path, settings_path).migrate()\\n except ConfigObjError, parsing_error:\\n print 'WARNING! corrupted configuration file replaced with defaults'\\n print parsing_error\\n shutil.copy(source_path, settings_path)\\n return os.path.abspath(settings_path)\",\n \"def load_settings(self):\\n # Set the default settings. In case in a later version of this script the settings change, new default variables will be added automatically\\n self.settings = {\\n # Connection settings to OBS Studio websockets plugin\\n \\\"host\\\": \\\"localhost\\\",\\n \\\"port\\\": 4444,\\n \\\"password\\\": \\\"\\\",\\n \\\"update_frequency\\\": 1, # seconds, how often the script loads the SC2 UI location\\n }\\n if os.path.isfile(self.settings_path):\\n with open(self.settings_path) as f:\\n self.settings.update(json.load(f))\",\n \"def _create_default_config(self):\\n self.options.setdefault('options.admin_passwd', '')\\n sys.path.append(self.openerp_dir)\\n sys.path.extend([egg.location for egg in self.ws])\\n from openerp.tools.config import configmanager\\n configmanager(self.config_path).save()\",\n \"def set_nfs_domain(session, domain, return_type=None, **kwargs):\\n body_values = {'domain': domain}\\n\\n path = '/api/settings/nfs_domain.json'\\n\\n return session.post_api(path=path, body=body_values,\\n return_type=return_type, **kwargs)\",\n \"def default_space_settings(self) -> Optional[pulumi.Input['DomainDefaultSpaceSettingsArgs']]:\\n return pulumi.get(self, \\\"default_space_settings\\\")\",\n \"def domain_prompt(self):\\n\\n # Domain selection prompt\\n domain_completer = FuzzyWordCompleter(\\n list(map(str.title, DOMAINS))\\n ) # Titlecase for aesthetics\\n selected_domain = DOMAINS.index(\\n prompt(\\\"Domain: \\\", completer=domain_completer).lower()\\n )\\n\\n print(\\\"Selected Domain: {}\\\".format(DOMAINS[selected_domain]))\\n self.domain = DOMAINS[selected_domain]\\n logging.info(\\\"Domain Selected\\\")\",\n \"def __init__(self, name, defaults = {} ):\\n self.defaults = defaults\\n self.filename = os.path.expanduser(name)+\\\".ini\\\"\\n self.conf = {}\\n self.reset()\\n if os.path.exists(self.filename):\\n self.load()\",\n \"def test_defaults_overrides_with_settings(settings):\\n\\n settings.MARION_DOCUMENT_ISSUER_CHOICES_CLASS = (\\n \\\"howard.documents.DocumentIssuerChoices\\\"\\n )\\n settings.MARION_DOCUMENTS_ROOT = Path(\\\"/tmp/documents/abc\\\")\\n settings.MARION_DOCUMENTS_TEMPLATE_ROOT = Path(\\\"howard/documents/abc\\\")\\n\\n # Force module reload to take into account setting override as it is loaded\\n # very early in the stack\\n importlib.reload(defaults)\\n\\n assert (\\n defaults.DOCUMENT_ISSUER_CHOICES_CLASS\\n == \\\"howard.documents.DocumentIssuerChoices\\\"\\n )\\n assert defaults.DOCUMENTS_ROOT == Path(\\\"/tmp/documents/abc\\\")\\n assert defaults.DOCUMENTS_TEMPLATE_ROOT == Path(\\\"howard/documents/abc\\\")\",\n \"def _define_settings(self):\\n\\n self.settings = {}\\n\\n ##### ORIGINALLY IN THE DOMAIN FILE #######\\n\\n # Maximum input in the C-Space : no constituent can be more than 100% present\\n self.settings['maxInp'] = 1\\n\\n #### ORIGINALLY IN THE SETTINGS FILE #####\\n self.settings[\\\"epochs\\\"] = 3 # Training epochs\\n self.settings[\\\"tgtStd\\\"] = 12e-6\\n self.settings['TInit'] = 1e-6\\n self.settings[\\\"TMin\\\"] = 0\\n self.settings[\\\"TDecayRate\\\"] = 0.05\\n self.settings[\\\"lambdaInit\\\"] = 0.011387\\n self.settings['lambdaMin'] = 0.0001\\n self.settings[\\\"lambdaDecayRate\\\"] = 0.60\\n self.settings[\\\"maxSteps\\\"] = 300000\\n self.settings[\\\"emaSpeedTol\\\"] = 0.009\\n self.settings[\\\"emaFactor\\\"] = .005\\n self.settings[\\\"printInterval\\\"] = 3000\\n self.settings[\\\"summary_file\\\"] = \\\"data/summary.txt\\\"\\n mean = torch.ones(self.grammar.bind.nF,\\n self.grammar.bind.nR)/self.grammar.bind.nF\\n self.settings[\\\"initStateMean\\\"] = mean\\n self.settings[\\\"initStateStdev\\\"] = .025\\n self.settings['clamp'] = False\\n\\n if self.custom_settings is not None:\\n for key, value in self.custom_settings.items():\\n if key in self.settings:\\n self.settings[key] = value\",\n \"def read_settings():\\n \\n settings = OrdDic()\\n settings.update(json.load(open(\\\"resources/files/settings.txt\\\", \\\"r\\\")))\\n\\n ## OLD WAY BELOW\\n\\n #r = open(\\\"resources/files/settings.txt\\\", \\\"r\\\", newline=\\\"\\\\n\\\")\\n # for option in r.read().split('\\\\n'):\\n # try:\\n # #option = option.split('\\\\\\\\')\\n # #settings.update({option[0]: option[1]})\\n # # settings.update(json.loads(option))\\n # except IndexError:\\n # pass\\n return settings\",\n \"def _new():\\n\\treturn ConfigParser(\\n\\tdelimiters = ('=',),\\n\\tcomment_prefixes = ('#', ';'),\\n\\tdefault_section = 'default',\\n\\tallow_no_value = False,\\n\\tstrict = False,\\n\\tinterpolation = ExtendedInterpolation(),\\n\\tdefaults = {\\n\\t\\t'debug': False,\\n\\t\\t'datadir': path.join(path.expanduser('~'), '.local', 'rosshm'),\\n\\t\\t'log.level': 'warn',\\n\\t\\t'core.enable': True,\\n\\t\\t'db.driver': 'sqlite',\\n\\t\\t'db.name': 'rosshmdb',\\n\\t\\t'db.config': '',\\n\\t\\t'static.enable': True,\\n\\t\\t'web.enable': True,\\n\\t},\\n)\",\n \"def add_new_domain(self):\\n\\n domain = self.dlg.uComboBoxDomain.currentText()\\n\\n if domain in self.domains:\\n self.dlg.uWarningSettings.show()\\n self.dlg.uWarningSettings.setText(\\n \\\"Warning: Domains must be unique. \\\" \\\"Please edit the domain below\\\"\\n )\\n return\\n\\n if len(self.domains) >= 10:\\n self.dlg.uWarningSettings.show()\\n self.dlg.uWarningSettings.setText(\\n \\\"Warning: You can only store up to . \\\" \\\"10 domain entries\\\"\\n )\\n return\\n\\n if domain == \\\"OTHER\\\":\\n domain = \\\"\\\"\\n getattr(self.dlg, \\\"uTextDomain{0}\\\".format(len(self.domains) + 1)).setText(\\n domain\\n )\\n getattr(self.dlg, \\\"uTextDomain{0}\\\".format(len(self.domains) + 1)).show()\\n getattr(self.dlg, \\\"uTextAPIKey{0}\\\".format(len(self.domains) + 1)).show()\\n getattr(self.dlg, \\\"uBtnRemoveDomain{0}\\\".format(len(self.domains) + 1)).show()\\n getattr(self.dlg, \\\"uBtnSaveDomain{0}\\\".format(len(self.domains) + 1)).show()\\n self.dlg.uWarningSettings.hide()\",\n \"def store_domain(self, store_domain):\\n self._store_domain = store_domain\\n return self\",\n \"def configure(prompt_list):\\n darwin_vers = int(os.uname()[2].split('.')[0])\\n edited_prefs = {}\\n for (key, prompt) in prompt_list:\\n newvalue = get_input_with_default('%15s: ' % prompt, pref(key))\\n if darwin_vers == 10:\\n # old behavior in SL: hitting return gives you an empty string,\\n # and means accept the default value.\\n edited_prefs[key] = newvalue or pref(key) or ''\\n else:\\n # just use the edited value as-is\\n edited_prefs[key] = newvalue\\n\\n if FOUNDATION_SUPPORT:\\n for key, value in edited_prefs.items():\\n try:\\n CFPreferencesSetAppValue(key, value, BUNDLE_ID)\\n except BaseException:\\n print('Could not save configuration!', file=sys.stderr)\\n raise ConfigurationSaveError\\n # remove repo_path if it exists since we don't use that\\n # any longer (except for backwards compatibility) and we don't\\n # want it getting out of sync with the repo_url\\n CFPreferencesSetAppValue('repo_path', None, BUNDLE_ID)\\n CFPreferencesAppSynchronize(BUNDLE_ID)\\n\\n else:\\n try:\\n existing_prefs = readPlist(PREFSPATH)\\n existing_prefs.update(edited_prefs)\\n # remove repo_path if it exists since we don't use that\\n # any longer (except for backwards compatibility) and we don't\\n # want it getting out of sync with the repo_url\\n if 'repo_path' in existing_prefs:\\n del existing_prefs['repo_path']\\n writePlist(existing_prefs, PREFSPATH)\\n except (IOError, OSError, ExpatError):\\n print('Could not save configuration to %s' % PREFSPATH,\\n file=sys.stderr)\\n raise ConfigurationSaveError\",\n \"def get(cls):\\n try:\\n return cls.objects.get(id=1)\\n except cls.DoesNotExist:\\n default_settings = SiteSettings(id=1)\\n default_settings.save()\\n return default_settings\",\n \"def init(args):\\n # reading existing config file, convert to configparser object\\n config = config_from_file()\\n config_ = configparser.ConfigParser()\\n config_.add_section('osf')\\n if 'username' not in config.keys():\\n config_.set('osf', 'username', '')\\n else:\\n config_.set('osf', 'username', config['username'])\\n if 'project' not in config.keys():\\n config_.set('osf', 'project', '')\\n else:\\n config_.set('osf', 'project', config['project'])\\n\\n # now we can start asking for new values\\n print('Provide a username for the config file [current username: {}]:'.format(\\n config_.get('osf', 'username')))\\n username = input()\\n if username:\\n config_.set('osf', 'username', username)\\n\\n print('Provide a project for the config file [current project: {}]:'.format(\\n config_.get('osf', 'project')))\\n project = input()\\n if project:\\n config_.set('osf', 'project', project)\\n\\n cfgfile = open(\\\".osfcli.config\\\", \\\"w\\\")\\n config_.write(cfgfile)\\n cfgfile.close()\",\n \"def setDefaultSettings():\\n if PLATFORM == 'Windows':\\n font = 'Consolas'\\n else:\\n font = 'Monospace'\\n\\n preferenceNode = nuke.toNode('preferences')\\n # viewer settings\\n preferenceNode['maxPanels'].setValue(5)\\n preferenceNode['TextureSize'].setValue('2048x2048')\\n preferenceNode['viewer_bg_color_3D'].setValue(1280068863)\\n preferenceNode['viewer_fg_color_3D'].setValue(4294967295L)\\n preferenceNode['Viewer3DControlEmulation'].setValue('Maya')\\n preferenceNode['middleButtonPans'].setValue(False)\\n preferenceNode['dot_node_scale'].setValue(1.5)\\n\\n # script editor settings\\n preferenceNode['clearOnSuccess'].setValue(False)\\n preferenceNode['echoAllCommands'].setValue(True)\\n preferenceNode['ScriptEditorFont'].setValue(font)\\n preferenceNode['ScriptEditorFontSize'].setValue(12.0)\\n preferenceNode['kwdsFgColour'].setValue(2629566719L)\\n preferenceNode['stringLiteralsFgColourDQ'].setValue(10354943)\\n preferenceNode['stringLiteralsFgColourSQ'].setValue(10354943)\\n preferenceNode['commentsFgColour'].setValue(2442236415L)\",\n \"def create_default_data():\\n db = sh.open(the_phone_book_name, flag='n', writeback=True)\\n phone_list = {'Bob': '6145617554',\\n 'Leslie': '3095551212',\\n 'Carol': '61455551212',\\n 'Rick': '8955551212'}\\n\\n for name_key in phone_list:\\n db[name_key] = phone_list[name_key]\\n db.sync()\\n db.close()\",\n \"def create_settings_file():\\n with open('./cfg/settings.cfg'.replace(\\\"/\\\", os.path.sep), 'w') as cfg:\\n cfg.write('[report]\\\\nlogo = ./cfg/logo.png\\\\ncompany =\\\\nrecord =\\\\nunit =\\\\nexaminer =\\\\nnotes =\\\\n\\\\n[auth]\\\\ngmail = alias@gmail.com\\\\npassw = yourpassword\\\\ndevid = 1234567887654321\\\\ncelnumbr = BackupPhoneNunmber\\\\n\\\\n[app]\\\\npkg = com.whatsapp\\\\nsig = 38a0f7d505fe18fec64fbf343ecaaaf310dbd799\\\\n\\\\n[client]\\\\npkg = com.google.android.gms\\\\nsig = 38918a453d07199354f8b19af05ec6562ced5788\\\\nver = 9877000'.replace(\\\"/\\\", os.path.sep))\",\n \"def __getSettingsFromStorage():\\n return AccountSettings.getSettings(NEW_SETTINGS_COUNTER)\",\n \"def __init__(self, argv: list, company: str, appname: str, Liststr=None):\\n if company is None:\\n company = self.__class__.__name__\\n QSettings.setPath(QSettings.IniFormat, QSettings.UserScope, str(FOLDER.parent / \\\"settings\\\"))\\n self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, company, appname)\\n super().__init__(argv)\",\n \"def test_settings_instantiation(self):\\n ## no settings passed on instantiation\\n bd = BorrowDirect() # no settings info\\n self.assertEqual(\\n True, isinstance(bd, BorrowDirect) )\\n ## dict settings\\n settings_dict = {} ## empty dct\\n bd = BorrowDirect( settings_dict )\\n self.assertEqual(\\n None, bd.UNIVERSITY_CODE )\\n settings_dict = { 'UNIVERSITY_CODE': '123' } ## populated dct\\n bd = BorrowDirect( settings_dict )\\n self.assertEqual(\\n '123', bd.UNIVERSITY_CODE )\\n ## module settings\\n s = imp.new_module( 'settings' ) ## empty module\\n bd = BorrowDirect( s )\\n self.assertEqual(\\n None, bd.UNIVERSITY_CODE )\\n s = imp.new_module( 'settings' ) ## populated module\\n s.UNIVERSITY_CODE = '234'\\n bd = BorrowDirect( s )\\n self.assertEqual(\\n '234', bd.UNIVERSITY_CODE )\",\n \"def get_pref(self, key, domain=BUNDLE_ID):\\n value = CFPreferencesCopyAppValue(key, domain) or None\\n # Casting NSArrays and NSDictionaries to native Python types.\\n # This a workaround for 10.6, where PyObjC doesn't seem to\\n # support as many common operations such as list concatenation\\n # between Python and ObjC objects.\\n if isinstance(value, NSArray):\\n value = list(value)\\n elif isinstance(value, NSDictionary):\\n value = dict(value)\\n return value\",\n \"def domain(self, domain):\\n self._domain = domain\",\n \"def domain(self, domain):\\n self._domain = domain\",\n \"def default_space_settings(self) -> pulumi.Output[Optional['outputs.DomainDefaultSpaceSettings']]:\\n return pulumi.get(self, \\\"default_space_settings\\\")\",\n \"def get_pref(key, domain=BUNDLE_ID):\\n if CFPreferencesCopyAppValue(key, domain):\\n return CFPreferencesCopyAppValue(key, domain)\\n return None\",\n \"def load_default_space_and_org(self):\\n try:\\n space_url = self.lookup_cf_response(\\\"default_space_url\\\")\\n except AttributeError:\\n return\\n space = self._fetcher.get_entities(space_url)\\n if 'organization_url' in space:\\n org_url = space['organization_url']\\n org = self._fetcher.get_entities(org_url)\\n\\n if ('name' in space) and ('name' in org):\\n self._default_organization = org['name']\\n self._default_space = space['name']\",\n \"def site(self, domain):\\r\\n return resource.Site(self, domain)\",\n \"def pref(pref_name):\\n default_prefs = {\\n 'ServerURL': 'http://munkiwebadmin',\\n 'authKey': '',\\n }\\n pref_value = CFPreferencesCopyAppValue(pref_name, BUNDLE_ID)\\n if pref_value is None:\\n pref_value = default_prefs.get(pref_name)\\n # we're using a default value. We'll write it out to\\n # /Library/Preferences/<BUNDLE_ID>.plist for admin\\n # discoverability\\n set_pref(pref_name, pref_value)\\n if isinstance(pref_value, NSDate):\\n # convert NSDate/CFDates to strings\\n pref_value = str(pref_value)\\n return pref_value\",\n \"def read_settings(self):\\n self.settings = read_settings(self.settings_path)\",\n \"def setPreferencesAtStartup(self):\\n\\t\\tif os.path.isfile(self.userPrefsFileName):\\n\\t\\t\\tprefs = open(self.userPrefsFileName, 'r')\\n\\t\\t\\tprefsLine = prefs.readline()\\n\\t\\t\\tprefs.close()\\n\\t\\t\\t\\n\\t\\t\\tfor i in range(0,len(prefsLine)):\\n\\t\\t\\t\\tc = prefsLine[i]\\n\\t\\t\\t\\tif c is not \\\"/\\\":\\n\\t\\t\\t\\t\\tself.setPreference(c)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tself.setPreference(prefsLine[i:])\\n\\t\\t\\t\\t\\tbreak\",\n \"def setupDefaultProperties( self, p, id, title, description, email_from_address, email_from_name,\\n validate_email, server_url, stemmer ):\\n p._setProperty( 'email_from_address', email_from_address, 'string' )\\n p._setProperty( 'email_from_name', email_from_name, 'string' )\\n p._setProperty( 'validate_email', validate_email and 1 or 0, 'boolean' )\\n p._setProperty( 'email_antispam', '', 'string' )\\n p._setProperty( 'email_error_address', '', 'string' )\\n p._setProperty( 'instance', id, 'string' )\\n p._setProperty( 'remote_url', '', 'string' )\\n\\n p._setProperty( 'apply_threading', 1, 'boolean' )\\n p._setProperty( 'use_timeout', 1, 'boolean' )\\n p._setProperty( 'duration', 0.001, 'float' )\\n p._setProperty( 'p_resolve_conflict', 0, 'boolean' )\\n\\n p._setProperty( 'max_involved_users', 10, 'int' )\\n p._setProperty( 'service_timeout', 30, 'int' )\\n p._setProperty( 'created_search_interval', 999, 'int' )\\n p._setProperty( 'common_url', '', 'string' )\\n\\n p._setProperty( 'send_to_support', 0, 'boolean' )\\n p._setProperty( 'member_activity', 1, 'boolean' )\\n p._setProperty( 'emergency_service', 0, 'boolean' )\\n p._setProperty( 'p_log', 0, 'boolean' )\\n\\n p._setProperty( 'suspended_mail', 1, 'boolean' )\\n p._setProperty( 'mail_frequency', 1, 'int' )\\n p._setProperty( 'mail_threshold', 500, 'int' )\\n\\n p._setPropValue( 'server_url', server_url )\\n p._setPropValue( 'stemmer', stemmer )\\n\\n p.title = title\\n p.description = description\",\n \"def create_default_config(self, parser):\\n parser.add_section('irc')\\n parser.set('irc', 'channels', '')\\n \\n # create the full path, and the file\\n try:\\n os.makedirs(self.config_dir_path, mode=0700)\\n except OSError:\\n pass\\n file_resource = open(self.config_file_path, 'w')\\n parser.write(file_resource)\",\n \"def fromenv(cls) -> 'Config':\\n files = Config.find_config_files()\\n if not files:\\n log.info(\\n \\\"Could not find default config: `~/.wpwatcher/wpwatcher.conf`, `~/wpwatcher.conf` or `./wpwatcher.conf`\\\"\\n )\\n return cls.default()\\n else:\\n return cls.fromfiles(files)\",\n \"def create_domain_name(self, DomainName: str, DomainNameConfigurations: List = None) -> Dict:\\n pass\",\n \"def __init__(self):\\n super(sppasPathSettings, self).__init__()\\n\\n sppas_dir = os.path.dirname(os.path.dirname(\\n os.path.dirname(os.path.abspath(__file__))))\\n\\n self.__dict__ = dict(\\n sppas=sppas_dir,\\n cli=os.path.join(sppas_dir, \\\"bin\\\"),\\n etc=os.path.join(sppas_dir, \\\"etc\\\"),\\n po=os.path.join(sppas_dir, \\\"po\\\"),\\n src=os.path.join(sppas_dir, \\\"src\\\"),\\n plugins=os.path.join(os.path.dirname(sppas_dir), \\\"plugins\\\"),\\n resources=os.path.join(os.path.dirname(sppas_dir), \\\"resources\\\"),\\n samples=os.path.join(os.path.dirname(sppas_dir), \\\"samples\\\"),\\n logs=os.path.join(os.path.dirname(sppas_dir), \\\".logs\\\"),\\n wkps=os.path.join(os.path.dirname(sppas_dir), \\\"workspaces\\\"),\\n trash=os.path.join(os.path.dirname(sppas_dir), \\\".trash\\\"),\\n )\",\n \"def create_domain(domain_id, default_role):\\n tx = iroha.transaction(\\n [iroha.command(\\\"CreateDomain\\\", domain_id=domain_id, default_role=\\\"user\\\")]\\n )\\n ic.sign_transaction(tx, user_private_key)\\n send_transaction_print_status_and_return_result(tx)\",\n \"def add_local_settings():\\n put('/Users/peter/Dropbox/Projects/ChromeFiddle/Local\\\\ Settings/prod/local_settings.py', \\n '/home/django/web/chromefiddle/chromefiddle/settings')\",\n \"def loadDefaults(self):\\n # (025) Merged into settings.RawSettings.\\n pass\",\n \"def test_domain(self):\\n self.assertEqual(self.gmail_case.domain, 'google.com')\\n self.gmail_case.domain = 'yahoo.com'\\n self.assertEqual(self.gmail_case.domain, 'yahoo.com')\\n self.assertEqual(self.sld_case.domain, 'amazon.co.uk')\\n self.assertEqual(self.gmail_case.tld, 'com')\\n self.assertEqual(self.sld_case.tld, 'co.uk')\\n self.gmail_case.tld = 'co.ke'\\n self.sld_case.tld = 'gov'\\n self.assertEqual(self.gmail_case.tld, 'co.ke')\\n self.assertEqual(self.sld_case.tld, 'gov')\\n self.assertEqual(self.gmail_case.domain, 'yahoo.co.ke')\\n self.assertEqual(self.sld_case.domain, 'amazon.gov')\",\n \"def auth_domain(request):\\n return request.registry.settings.get('h.auth_domain', request.domain)\",\n \"def load_preferences(self):\\n\\n print 'Loading current DNAtool preferences'\\n self.preferences = Preferences('DNAtool',{'canvas_height':600})\\n\\n for key in self.defaultprefs:\\n if key in self.preferences.prefs:\\n self.__dict__[key].set(self.preferences.get(key))\\n else:\\n self.preferences.set(key, self.defaultprefs[key])\\n\\n self.update_window_formatting()\\n return\",\n \"def settings():\\n return _get_settings()[1]\",\n \"def return_domain_values(hostname, domain_name, username):\\n myconnection = ssh_connection(hostname, username)\\n if myconnection == 1:\\n return \\\"Connection to %s failed\\\" % hostname\\n else:\\n #If the user want the defaults values\\n if domain_name == \\\"default\\\":\\n list = []\\n #Get the default destination\\n stdin, stdout, stderr = myconnection.exec_command(\\\"/bin/cat /etc/postfix/main.cf | grep default_destination | cut -d '=' -f 2\\\" )\\n out=stdout.read().splitlines()\\n else:\\n # Send the command (non-blocking)\\n commandline=\\\"/bin/cat /etc/postfix/main.cf | grep %s | cut -d '=' -f 2\\\" % (domain_name)\\n stdin, stdout, stderr = myconnection.exec_command(commandline)\\n\\n #On récupère la sortie standard\\n out=stdout.read().splitlines()\\n\\n if not out:\\n # Disconnect from the host\\n myconnection.close()\\n return \\\"No value for this domain. Are you sure this domain exist ?\\\"\\n exit(1)\\n else:\\n # Disconnect from the host\\n myconnection.close()\\n #On retourne la liste des domaines\\n return out\",\n \"def domain_profile(self, domain):\\n return self.apiquery('/v1/{}'.format(domain))\",\n \"def _update_site_configuration(self):\\n self.site.configuration.site_values = {'THIRD_PARTY_AUTH_ONLY_DOMAIN': self.email_domain_name}\\n self.site.configuration.save()\",\n \"def readSettings(self):\\n settings = QtCore.QSettings()\\n # defaults to the current directory path\\n current_dir_abspath = os.path.abspath('')\\n defaultValue = QtCore.QString(current_dir_abspath)\\n # Warning:\\n # QSettings.value can return different types (QVariant types) depending on the platform it's running on,\\n # so the safest way to use it is always casting the result to the desired type, e.g.: int(settings.value(\\\"myKey\\\")).\\n output_directory = settings.value(\\\"output_directory\\\", defaultValue=defaultValue).toString()\\n self.ui.outputDirLineEdit.setText(output_directory)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5657144","0.548896","0.5319334","0.5285291","0.52768016","0.5255273","0.5222265","0.5218223","0.5189833","0.5173989","0.5170184","0.51397663","0.513596","0.5086622","0.50810987","0.50810987","0.50761354","0.5024908","0.5006228","0.5000491","0.5000396","0.49986142","0.4996676","0.49652752","0.49533844","0.49051794","0.48797652","0.4865534","0.48620728","0.48614177","0.48597506","0.4847769","0.4843209","0.4833179","0.48037443","0.47932178","0.47857103","0.47780803","0.47713098","0.47710988","0.47681555","0.47639725","0.47537604","0.47521138","0.474266","0.4737899","0.47365564","0.4732378","0.47241792","0.47217092","0.47179455","0.47144186","0.47105816","0.47013402","0.46968982","0.46849087","0.46848226","0.46632504","0.46605426","0.4656445","0.4655388","0.46544835","0.46500567","0.46403474","0.46385905","0.46312255","0.46265006","0.46198565","0.46143794","0.46005353","0.45965722","0.45923698","0.4590082","0.45832923","0.45782843","0.4578194","0.4578194","0.45761475","0.45709032","0.45672768","0.45634302","0.456294","0.4557878","0.45555392","0.45546755","0.45505056","0.45333612","0.45328987","0.45310566","0.45269844","0.4523721","0.451705","0.4515607","0.45094514","0.4509354","0.45090604","0.45041662","0.45019066","0.44985747","0.44964528"],"string":"[\n \"0.5657144\",\n \"0.548896\",\n \"0.5319334\",\n \"0.5285291\",\n \"0.52768016\",\n \"0.5255273\",\n \"0.5222265\",\n \"0.5218223\",\n \"0.5189833\",\n \"0.5173989\",\n \"0.5170184\",\n \"0.51397663\",\n \"0.513596\",\n \"0.5086622\",\n \"0.50810987\",\n \"0.50810987\",\n \"0.50761354\",\n \"0.5024908\",\n \"0.5006228\",\n \"0.5000491\",\n \"0.5000396\",\n \"0.49986142\",\n \"0.4996676\",\n \"0.49652752\",\n \"0.49533844\",\n \"0.49051794\",\n \"0.48797652\",\n \"0.4865534\",\n \"0.48620728\",\n \"0.48614177\",\n \"0.48597506\",\n \"0.4847769\",\n \"0.4843209\",\n \"0.4833179\",\n \"0.48037443\",\n \"0.47932178\",\n \"0.47857103\",\n \"0.47780803\",\n \"0.47713098\",\n \"0.47710988\",\n \"0.47681555\",\n \"0.47639725\",\n \"0.47537604\",\n \"0.47521138\",\n \"0.474266\",\n \"0.4737899\",\n \"0.47365564\",\n \"0.4732378\",\n \"0.47241792\",\n \"0.47217092\",\n \"0.47179455\",\n \"0.47144186\",\n \"0.47105816\",\n \"0.47013402\",\n \"0.46968982\",\n \"0.46849087\",\n \"0.46848226\",\n \"0.46632504\",\n \"0.46605426\",\n \"0.4656445\",\n \"0.4655388\",\n \"0.46544835\",\n \"0.46500567\",\n \"0.46403474\",\n \"0.46385905\",\n \"0.46312255\",\n \"0.46265006\",\n \"0.46198565\",\n \"0.46143794\",\n \"0.46005353\",\n \"0.45965722\",\n \"0.45923698\",\n \"0.4590082\",\n \"0.45832923\",\n \"0.45782843\",\n \"0.4578194\",\n \"0.4578194\",\n \"0.45761475\",\n \"0.45709032\",\n \"0.45672768\",\n \"0.45634302\",\n \"0.456294\",\n \"0.4557878\",\n \"0.45555392\",\n \"0.45546755\",\n \"0.45505056\",\n \"0.45333612\",\n \"0.45328987\",\n \"0.45310566\",\n \"0.45269844\",\n \"0.4523721\",\n \"0.451705\",\n \"0.4515607\",\n \"0.45094514\",\n \"0.4509354\",\n \"0.45090604\",\n \"0.45041662\",\n \"0.45019066\",\n \"0.44985747\",\n \"0.44964528\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7057614"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3191,"cells":{"query":{"kind":"string","value":"Create and return a GroupGuard for this Settings object, which prepends a group name to all settings names referenced while it is active."},"document":{"kind":"string","value":"def groupGuard(self, groupNameRaw):\n\t\tgroupName = str(groupNameRaw)\n\t\tif self.__DELIMITER in groupName:\n\t\t\traise ValueError((\"Illegal group name '%s' contains\"\n\t\t\t+ \" delimiter '%s'.\") % (groupName, self.__DELIMITER))\n\t\treturn self._GroupGuard(self, groupName)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make_grp(self, name='grp'):\n self.base[name] = self.get_group_array()","def createGroup(self):\n return _libsbml.GroupsModelPlugin_createGroup(self)","def save_group_and_return_instance(self, groupname=\"\"):\n if groupname == \"\":\n raise ValueError(\"group needs its name.\")\n group = Group(name=groupname)\n self.save_object(group)\n return group","def get_new_config_group(self):\n filename = \"%(config_dir)s/%(group)s.%(time)s\" % \\\n { \"config_dir\": self.config_dir(),\n \"group\": self.group_name(),\n \"time\": common.time_suffix(),}\n common.write_file(\"w\", 0o644, filename, self.get_match_criteria())","def make_grp(self, name='grp', v=False):\n self.base[name] = self.get_group_array(v=v) #np.zeros(len(self.base), dtype=int)#self.get_group_array()","def group(self):\n cook = cookie()\n G = Group('%s.G_%s' % (self.groupName, cook), self.socket, self)\n self.call('group', cook)\n return G","def settings_grp(self):\n settings_grp = self.h5[SETTINGS]\n return settings_grp","def gen_group(group_name=None, group_vars={}):\n group = Group(name=group_name)\n for key, value in group_vars.iteritems():\n group.set_variable(key, value)\n return group","def make_grp(self):\n try:\n self.base['grp']\n except:\n self.base['grp'] = np.zeros(len(self.base),dtype='i')\n\n for halo in self._halos.values():\n halo[name][:] = halo._halo_id\n\n if config['verbose']: print \"writing %s\"%(self._base().filename+'.grp')\n self._base().write_array('grp',overwrite=True,binary=False)","def make_groups(self):\n for g in self.groups:\n self.add_group(groupname=g['groupname'],\n grouptitle=g['grouptitle'],\n path_to_group=g['path'])","def createMainGroup(self):\n\t\tmc.group( n = self.grp.name, em = True )","def __create_group(self):\n\n group = time.strftime(_GROUP_NAME_FORMAT, time.localtime())\n LOG.info(\"Creating backup group '%s'.\", group)\n\n group_path = self.group_path(group)\n\n try:\n os.mkdir(group_path)\n except EnvironmentError as e:\n if e.errno != errno.EEXIST:\n raise Error(\"Unable to create a new backup group '{}': {}.\",\n group_path, psys.e(e))\n\n self.__on_group_created(group)\n\n return group","def createGroup(self):\n return _libsbml.ListOfGroups_createGroup(self)","def group(self) -> \"Group\":\n return Group(connection=self)","def get_group_name(self):\n return self.groupname","def groups(self):\n new = self.copy()\n new._filter = [\"groups\"]\n return new","def group(self, val):\n self.set_property(\"Group\", val)","def group_name(self):\n\n return self._group_name","def collapsed_to_hg_group(self):\n return op.join(self.collapse_to_hg_dir, \"touse.group.txt\")","def require_group(self, name) -> \"GroupBase\":\n if name not in self:\n return self.create_group(name)\n\n group = self[name]\n if not isinstance(group, GroupBase):\n raise TypeError(f\"Incompatible object ({type(group)}) already exists\")\n\n return group","def as_group(self, name=None):\n from . import groups\n\n if name:\n _rv = groups.NamedGroup((self,), name)\n else:\n _rv = groups.Group((self,))\n return _rv","def _create_child_group(self, name) -> \"GroupBase\":\n pass","def add_group(self, key):\n grp = GroupExplorator(self, key)\n self._grps[key] = grp\n return grp","def group_name(self) -> str:\n return pulumi.get(self, \"group_name\")","def with_group(self, group):\n\t\tself.variables['group'] = group\n\t\treturn self","def set_group_name(self, name):\n self.groupname = name","def group(self):\n return self.properties.get('Group', None)","def getGroup(self, name):\n return Group.create(self.pm_getUserManager().getGroup(self._unbox(name)), self._modelDataManager)","def get_group(self) -> Optional[str]:\n return self.group","def group(self) -> str:\n return pulumi.get(self, \"group\")","def get_group(self):\n\t\treturn self.variables.get('group')","def group(self) -> str:\n return self._db_data.group","def give_group(self, key):\n return self._grps[key]","def create_group(self, name) -> \"GroupBase\":\n ancestor, group_names, last_name = self._descend(name)\n parent = ancestor._require_descendant_groups(*group_names)\n if last_name in parent:\n raise FileExistsError(f\"Group or dataset found at '{name}'\")\n return parent._create_child_group(last_name)","def Group_created_by(Groupname):\r\n return Group.Group_created_by(Groupname)","def get_group(self, group_name):\n\n return self._group[group_name]","def _make_group(self, _rk, _group_hint):\n\n if isinstance(_group_hint, dict):\n # _group_hint is a single key/value pair\n g = _group_hint[list(_group_hint)[0]]\n\n r_type = g.get(\"type\", \"none\")\n if r_type != \"OS::Nova::ServerGroup\":\n return \"support only ServerGroup resource\"\n\n properties = g.get(\"properties\", {})\n if len(properties) == 0:\n return \"no properties\"\n\n group_name = properties.get(\"name\", None)\n if group_name is None:\n return \"no group name\"\n group_name = group_name.strip()\n\n policies = properties.get(\"policies\", [])\n if len(policies) == 0:\n return \"no policy of the group\"\n\n if len(policies) > 1:\n return \"multiple policies\"\n\n # TODO: exclude soft-affinity and soft-anti-affinity?\n\n if group_name in self.groups.keys():\n group = self.groups[group_name]\n else:\n group = Group(group_name)\n\n policy = policies[0].strip()\n if policy == \"anti-affinity\":\n group_type = \"diversity\"\n else:\n group_type = policy\n\n group.group_type = group_type\n group.factory = \"server-group\"\n group.level = \"host\"\n\n self.groups[group_name] = group\n else:\n # group hint is uuid string.\n rg = self.resource.get_group_by_uuid(_group_hint)\n if rg is None:\n return \"unknown group found while making group\"\n\n # TODO: exclude soft-affinity and soft-anti-affinity?\n\n if rg.name in self.groups.keys():\n group = self.groups[rg.name]\n else:\n group = Group(rg.name)\n\n group.group_type = rg.group_type\n group.factory = rg.factory\n group.level = \"host\"\n\n self.groups[rg.name] = group\n\n if group is not None:\n group.server_list.append(self.app_name + \":\" + _rk)\n\n return \"ok\"","def set_up_groups(self):\n groups = []\n groups.append({'groupname': 'th',\n 'grouptitle': 'TH',\n 'path': '/'})\n groups.append({'groupname': 'neutronics',\n 'grouptitle': 'Neutronics',\n 'path': '/'})\n groups.append({'groupname': 'metadata',\n 'grouptitle': 'Simulation Metadata',\n 'path': '/'})\n return groups","def __make_group_by_res(self, group_name, name_list):\r\n if group_name not in self.groups:\r\n res_group = self.group['Residue'].getChildGrps()\r\n groups = [ res for res in res_groups if res.name in name_list ]\r\n new_group = Group(parent=[], id=-1, type=group_name, childs=groups)\r\n self.groups[group_name] = new_group","def with_groups_allowed(self, groups_allowed: int) -> Creature:\n result = self.clone()\n result.groups_allowed = groups_allowed\n return result","def group(self) -> Optional[str]:\n return pulumi.get(self, \"group\")","def group(self):\n return self._group","def group(self):\n return self._group","def group(self):\n return self._group","def get_group(self):\n return self._group","def group_name(self):\n return \"room-%s\" % self.id","def group_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"group_name\")","def group_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"group_name\")","def group_name(self):\n return \"room-%s\" % self.pk","def group_name(self):\n return \"room-%s\" % self.pk","def createGroup(self, name):\n new_group = ET.SubElement(self._root,'group')\n group_name = ET.SubElement(new_group, 'name')\n group_name.text = name\n # update the document's groups\n self._groups = self._root.findall('group') \n print 'Creating group, \\'%s\\'' % name\n return CAGroup(new_group)","def ad_group_name(self):\n\n return self._ad_group_name","def ad_group_name(self):\n\n return self._ad_group_name","def _set_group_name(self):\n self._scene_gen.group_name = self._group_name_le.text()\n self._refresh_view()","def make_group(self, id, name='', attrs={}, link='', abort=True ): \n gid = id + \"/\"\n sgd = self.get_sgd(gid, name)\n path = self.full_path\n link_info = self.file.extract_link_info(name, link, Group)\n if not abort:\n # id = sgd['id'].rstrip('/') # not sure if need this\n grp = self.file.get_existing_group(path, id, name)\n if grp:\n return grp\n grp = Group(self.file, sgd, name, path, attrs, self, link_info)\n # self.mstats[gid]['created'].append(grp)\n return grp","def copy_group(self):\n dd = self.destination_directory\n sg = self.source_group\n dg = self.destination_group\n\n data = {\n 'description': sg.description,\n 'name': sg.name,\n 'status': sg.status,\n }\n\n # If this Group already exists, we'll just update it.\n if dg:\n for key, value in data.items():\n setattr(dg, key, value)\n\n while True:\n try:\n dg.save()\n return dg\n except StormpathError as err:\n logger.error('Failed to copy Group: {} into Directory: {} ({})'.format(sg.name.encode('utf-8'), dd.name.encode('utf-8'), err))\n\n # If we get here, it means we need to create the Group from scratch.\n while True:\n try:\n return dd.groups.create(data)\n except StormpathError as err:\n logger.error('Failed to copy Group: {} into Directory: {} ({})'.format(sg.name.encode('utf-8'), dd.name.encode('utf-8'), err))","def condition_group_options(self):\n if \"no-groups\" in self.options and self.options[\"no-groups\"]:\n self.options[\"groups\"] = []\n if \"exclude-groups\" in self.options:\n del self.options[\"exclude-groups\"]\n\n return\n\n super().condition_group_options()","def group_name(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"group_name\")","def settings_group_options():\n return [('', _('No group')), *[(str(a.id), str(a)) for a in Group.objects.all()]]","def __str__(self):\n\n return 'Group(%s)' % self.id","def create_placement_group(self, name, strategy='cluster'):\r\n params = {'GroupName':name, 'Strategy':strategy}\r\n group = self.get_status('CreatePlacementGroup', params, verb='POST')\r\n return group","def create_new_group(self, a, b):\n self.groups[self.group_id] = set([a,b])\n self.node_id[a] = self.node_id[b] = self.group_id\n self.group_id += 1","def group(cls):\n return relationship.many_to_one(cls, 'group')","def _process_group(self, **config_kwargs) -> RobotGroupConfig:\n return RobotGroupConfig(self.sim_scene, **config_kwargs)","def group(*args, absolute: bool=True, empty: bool=True, name: AnyStr=\"\", parent: AnyStr=\"\",\n relative: bool=True, useAsGroup: AnyStr=\"\", world: bool=True, **kwargs)->AnyStr:\n pass","def space_group(self) -> PermutationGroup:\n return self._full_translation_group @ self.point_group","def get_security_group_short_name(self):\n return self.config['security_group']","def add_bu_group(self, **kwargs):\n _stringify_kw(kwargs)\n \n bu_group = ElementTree.Element(xml_strings['backup_group'], **kwargs)\n self._root.append(bu_group)\n return XMLGroupOverlay(bu_group, self._root)","def get_grp_string(self):\n\n grp = self.get_grp()\n\n if grp == -1:\n\n return \"\"\n\n return \"grp \" + str(grp)","def koie_group():\n return GroupFactory(name=\"Koiene\")","def append_groups(self, name, groups):\r\n self.__groups[name] = groups","def autoCreateGroup(cleaned_data, cookie_user, isAutoApproved=False, querystring_content=False):\n existingSites = Site.objects.filter(\n domain=cleaned_data['domain'],\n )\n if len(existingSites) > 0:\n\n try:\n site = existingSites[0]\n group = site.group\n except Exception, e:\n raise Exception(\"Site \"+cleaned_data['domain']+\" has no group.\")\n else:\n # make a group and site\n try:\n group = Group.objects.create(\n name=cleaned_data['name'],\n short_name=cleaned_data['short_name'],\n approved=False,\n temp_interact=0,\n requires_approval=False,\n )\n except Exception, e:\n print \"* * * ** * * * * * * * EXCEPTION \"\n print e\n logger.warn(e)\n groups = Group.objects.filter(\n short_name=cleaned_data['short_name']\n )\n if len(groups) == 1:\n group = groups[0]\n elif len(groups) > 1:\n raise Exception(\"More than one group with shortname found: \" + cleaned_data['short_name'])\n else:\n raise Exception(\"No groups found with shortname: \" + cleaned_data['short_name'])\n\n site = Site.objects.create(\n name=cleaned_data['domain'],\n domain=cleaned_data['domain'],\n group=group,\n # this is whether or not a querystring is counted in the url - we should rename this\n querystring_content=querystring_content,\n )\n\n blessed_tags = addDefaultsForNewGroup(group, cookie_user)\n autoApproveUserAsAdmin(group, cookie_user, isAutoApproved=isAutoApproved)\n\n return group, site, blessed_tags","def space_group(self, point_group: Optional[PointGroup] = None) -> PermutationGroup:\n return self.space_group_builder(point_group).space_group","def clone(self):\n return _libsbml.Group_clone(self)","def findGroup(self, name):\n for g in self._groups:\n if g.find('name').text.strip() == name:\n return CAGroup(g)\n \n # If we are here the group does not exist\n\n g = ET.SubElement(self._root, 'group')\n n = ET.SubElement(g, 'name')\n n.text = name.strip()\n return CAGroup(g)","def create_group(self, name):\n\t\tdata = {\"name\":name}\n\t\tresponse = self.client.post(self._endpoint + \"/group\", content=data)\n\t\treturn Group(\n\t\t\tresponse.json['group_id'],\n\t\t\tself.user_id,\n\t\t\tself.site_id,\n\t\t\tdata=response.json\n\t\t)","def log_group_name(self) -> typing.Optional[str]:\n return self._values.get('log_group_name')","def make_group(self, qid, name='', path='', attrs={}, link='', abort=True):\n gqid = qid + \"/\"\n sdef = self.get_sdef(gqid, self.default_ns, \"referenced in make_group\")\n id = sdef['id']\n ns = sdef['ns']\n path = self.deduce_path(id, ns, path)\n if not abort:\n id_noslash = id.rstrip('/') # could be different from gqid if namespace present\n grp = self.get_existing_group(path, id_noslash, name)\n if grp:\n # found already existing group\n return grp \n link_info = self.extract_link_info(name, link, Group)\n # create the group\n parent = None # no parent since this node created from File object (top level)\n grp = Group(self, sdef, name, path, attrs, parent, link_info)\n return grp","def group(self):\n return self.tr(self.groupId())","def group(self):\n return self.tr(self.groupId())","def group(self):\n return self.tr(self.groupId())","def group(self):\n return self.tr(self.groupId())","def instance_group(self):\n return self._instance_group","def getGroupingStrategyFactory(self) -> cern.japc.core.spi.group.GroupSubscriptionStrategyFactory:\n ...","def __create_new_group(self, group_name) -> None:\n group = Group(name=group_name)\n group.save()\n\n self.__add_permission_to_group(group)","def create_group(self, label):\n group = OptionGroup(label)\n self.append(group)\n return group","def create_group(self):\n # TODO: Assuming first server is good - need to make fallback logic\n return self.session.get_any(\"{base}{request_url}\".format(base=self.servers[0],\n request_url=F\"/GroupV2/Create/\"))","def group(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"group\")","def group(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"group\")","def group(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"group\")","def log_group_name(self) -> str:\n ...","def create_group(self, name, track_order=False):\n full_name = self._get_h5_path(name)\n with open_hdf5(self.file_name, mode=\"a\") as h:\n try:\n h.create_group(full_name, track_order=track_order)\n except ValueError:\n pass\n h_new = self[name].copy()\n return h_new","def placement_group(template, name):\n p = PlacementGroup(name, template=template)\n p.Strategy = 'cluster'\n return p","def get_joining_group_property(value, limit_ascii=False):\n\n obj = unidata.ascii_joining_group if limit_ascii else unidata.unicode_joining_group\n\n if value.startswith('^'):\n negated = value[1:]\n value = '^' + unidata.unicode_alias['joininggroup'].get(negated, negated)\n else:\n value = unidata.unicode_alias['joininggroup'].get(value, value)\n\n return obj[value]","def register_group(self, cls):\n return self.register_entity('group', cls)","def group_settings_greedy(obs_expt: ObservablesExperiment):\n diag_sets = _max_tpb_overlap(obs_expt)\n grouped_expt_settings_list = list(diag_sets.values())\n grouped_obs_expt = ObservablesExperiment(grouped_expt_settings_list, program=obs_expt.program)\n return grouped_obs_expt","def clean_group_name(self):\r\n group_name = self.cleaned_data['group_name']\r\n master_id = 0\r\n\r\n if self.instance:\r\n # master id is used to exclude current master so that it is not checked as duplicate\r\n master_id = self.instance.id\r\n\r\n if LedgerGroup.objects.filter(company=self.company, group_name__iexact=group_name).exclude(id=master_id).exists():\r\n raise forms.ValidationError(\"Group name already exists\")\r\n\r\n return group_name","def setGroup(self, group):\n\t\tself.config.GROUP = group","def reserve_group(self, name, sco):\n\t\tif self.client is None:\n\t\t\traise UsageError(\"Not connected!\")\n\t\treturn self.client.reserve_group(name, sco)","def test_save(self, name='test'):\n group = Group(name=name)\n group.save()\n return group"],"string":"[\n \"def make_grp(self, name='grp'):\\n self.base[name] = self.get_group_array()\",\n \"def createGroup(self):\\n return _libsbml.GroupsModelPlugin_createGroup(self)\",\n \"def save_group_and_return_instance(self, groupname=\\\"\\\"):\\n if groupname == \\\"\\\":\\n raise ValueError(\\\"group needs its name.\\\")\\n group = Group(name=groupname)\\n self.save_object(group)\\n return group\",\n \"def get_new_config_group(self):\\n filename = \\\"%(config_dir)s/%(group)s.%(time)s\\\" % \\\\\\n { \\\"config_dir\\\": self.config_dir(),\\n \\\"group\\\": self.group_name(),\\n \\\"time\\\": common.time_suffix(),}\\n common.write_file(\\\"w\\\", 0o644, filename, self.get_match_criteria())\",\n \"def make_grp(self, name='grp', v=False):\\n self.base[name] = self.get_group_array(v=v) #np.zeros(len(self.base), dtype=int)#self.get_group_array()\",\n \"def group(self):\\n cook = cookie()\\n G = Group('%s.G_%s' % (self.groupName, cook), self.socket, self)\\n self.call('group', cook)\\n return G\",\n \"def settings_grp(self):\\n settings_grp = self.h5[SETTINGS]\\n return settings_grp\",\n \"def gen_group(group_name=None, group_vars={}):\\n group = Group(name=group_name)\\n for key, value in group_vars.iteritems():\\n group.set_variable(key, value)\\n return group\",\n \"def make_grp(self):\\n try:\\n self.base['grp']\\n except:\\n self.base['grp'] = np.zeros(len(self.base),dtype='i')\\n\\n for halo in self._halos.values():\\n halo[name][:] = halo._halo_id\\n\\n if config['verbose']: print \\\"writing %s\\\"%(self._base().filename+'.grp')\\n self._base().write_array('grp',overwrite=True,binary=False)\",\n \"def make_groups(self):\\n for g in self.groups:\\n self.add_group(groupname=g['groupname'],\\n grouptitle=g['grouptitle'],\\n path_to_group=g['path'])\",\n \"def createMainGroup(self):\\n\\t\\tmc.group( n = self.grp.name, em = True )\",\n \"def __create_group(self):\\n\\n group = time.strftime(_GROUP_NAME_FORMAT, time.localtime())\\n LOG.info(\\\"Creating backup group '%s'.\\\", group)\\n\\n group_path = self.group_path(group)\\n\\n try:\\n os.mkdir(group_path)\\n except EnvironmentError as e:\\n if e.errno != errno.EEXIST:\\n raise Error(\\\"Unable to create a new backup group '{}': {}.\\\",\\n group_path, psys.e(e))\\n\\n self.__on_group_created(group)\\n\\n return group\",\n \"def createGroup(self):\\n return _libsbml.ListOfGroups_createGroup(self)\",\n \"def group(self) -> \\\"Group\\\":\\n return Group(connection=self)\",\n \"def get_group_name(self):\\n return self.groupname\",\n \"def groups(self):\\n new = self.copy()\\n new._filter = [\\\"groups\\\"]\\n return new\",\n \"def group(self, val):\\n self.set_property(\\\"Group\\\", val)\",\n \"def group_name(self):\\n\\n return self._group_name\",\n \"def collapsed_to_hg_group(self):\\n return op.join(self.collapse_to_hg_dir, \\\"touse.group.txt\\\")\",\n \"def require_group(self, name) -> \\\"GroupBase\\\":\\n if name not in self:\\n return self.create_group(name)\\n\\n group = self[name]\\n if not isinstance(group, GroupBase):\\n raise TypeError(f\\\"Incompatible object ({type(group)}) already exists\\\")\\n\\n return group\",\n \"def as_group(self, name=None):\\n from . import groups\\n\\n if name:\\n _rv = groups.NamedGroup((self,), name)\\n else:\\n _rv = groups.Group((self,))\\n return _rv\",\n \"def _create_child_group(self, name) -> \\\"GroupBase\\\":\\n pass\",\n \"def add_group(self, key):\\n grp = GroupExplorator(self, key)\\n self._grps[key] = grp\\n return grp\",\n \"def group_name(self) -> str:\\n return pulumi.get(self, \\\"group_name\\\")\",\n \"def with_group(self, group):\\n\\t\\tself.variables['group'] = group\\n\\t\\treturn self\",\n \"def set_group_name(self, name):\\n self.groupname = name\",\n \"def group(self):\\n return self.properties.get('Group', None)\",\n \"def getGroup(self, name):\\n return Group.create(self.pm_getUserManager().getGroup(self._unbox(name)), self._modelDataManager)\",\n \"def get_group(self) -> Optional[str]:\\n return self.group\",\n \"def group(self) -> str:\\n return pulumi.get(self, \\\"group\\\")\",\n \"def get_group(self):\\n\\t\\treturn self.variables.get('group')\",\n \"def group(self) -> str:\\n return self._db_data.group\",\n \"def give_group(self, key):\\n return self._grps[key]\",\n \"def create_group(self, name) -> \\\"GroupBase\\\":\\n ancestor, group_names, last_name = self._descend(name)\\n parent = ancestor._require_descendant_groups(*group_names)\\n if last_name in parent:\\n raise FileExistsError(f\\\"Group or dataset found at '{name}'\\\")\\n return parent._create_child_group(last_name)\",\n \"def Group_created_by(Groupname):\\r\\n return Group.Group_created_by(Groupname)\",\n \"def get_group(self, group_name):\\n\\n return self._group[group_name]\",\n \"def _make_group(self, _rk, _group_hint):\\n\\n if isinstance(_group_hint, dict):\\n # _group_hint is a single key/value pair\\n g = _group_hint[list(_group_hint)[0]]\\n\\n r_type = g.get(\\\"type\\\", \\\"none\\\")\\n if r_type != \\\"OS::Nova::ServerGroup\\\":\\n return \\\"support only ServerGroup resource\\\"\\n\\n properties = g.get(\\\"properties\\\", {})\\n if len(properties) == 0:\\n return \\\"no properties\\\"\\n\\n group_name = properties.get(\\\"name\\\", None)\\n if group_name is None:\\n return \\\"no group name\\\"\\n group_name = group_name.strip()\\n\\n policies = properties.get(\\\"policies\\\", [])\\n if len(policies) == 0:\\n return \\\"no policy of the group\\\"\\n\\n if len(policies) > 1:\\n return \\\"multiple policies\\\"\\n\\n # TODO: exclude soft-affinity and soft-anti-affinity?\\n\\n if group_name in self.groups.keys():\\n group = self.groups[group_name]\\n else:\\n group = Group(group_name)\\n\\n policy = policies[0].strip()\\n if policy == \\\"anti-affinity\\\":\\n group_type = \\\"diversity\\\"\\n else:\\n group_type = policy\\n\\n group.group_type = group_type\\n group.factory = \\\"server-group\\\"\\n group.level = \\\"host\\\"\\n\\n self.groups[group_name] = group\\n else:\\n # group hint is uuid string.\\n rg = self.resource.get_group_by_uuid(_group_hint)\\n if rg is None:\\n return \\\"unknown group found while making group\\\"\\n\\n # TODO: exclude soft-affinity and soft-anti-affinity?\\n\\n if rg.name in self.groups.keys():\\n group = self.groups[rg.name]\\n else:\\n group = Group(rg.name)\\n\\n group.group_type = rg.group_type\\n group.factory = rg.factory\\n group.level = \\\"host\\\"\\n\\n self.groups[rg.name] = group\\n\\n if group is not None:\\n group.server_list.append(self.app_name + \\\":\\\" + _rk)\\n\\n return \\\"ok\\\"\",\n \"def set_up_groups(self):\\n groups = []\\n groups.append({'groupname': 'th',\\n 'grouptitle': 'TH',\\n 'path': '/'})\\n groups.append({'groupname': 'neutronics',\\n 'grouptitle': 'Neutronics',\\n 'path': '/'})\\n groups.append({'groupname': 'metadata',\\n 'grouptitle': 'Simulation Metadata',\\n 'path': '/'})\\n return groups\",\n \"def __make_group_by_res(self, group_name, name_list):\\r\\n if group_name not in self.groups:\\r\\n res_group = self.group['Residue'].getChildGrps()\\r\\n groups = [ res for res in res_groups if res.name in name_list ]\\r\\n new_group = Group(parent=[], id=-1, type=group_name, childs=groups)\\r\\n self.groups[group_name] = new_group\",\n \"def with_groups_allowed(self, groups_allowed: int) -> Creature:\\n result = self.clone()\\n result.groups_allowed = groups_allowed\\n return result\",\n \"def group(self) -> Optional[str]:\\n return pulumi.get(self, \\\"group\\\")\",\n \"def group(self):\\n return self._group\",\n \"def group(self):\\n return self._group\",\n \"def group(self):\\n return self._group\",\n \"def get_group(self):\\n return self._group\",\n \"def group_name(self):\\n return \\\"room-%s\\\" % self.id\",\n \"def group_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"group_name\\\")\",\n \"def group_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"group_name\\\")\",\n \"def group_name(self):\\n return \\\"room-%s\\\" % self.pk\",\n \"def group_name(self):\\n return \\\"room-%s\\\" % self.pk\",\n \"def createGroup(self, name):\\n new_group = ET.SubElement(self._root,'group')\\n group_name = ET.SubElement(new_group, 'name')\\n group_name.text = name\\n # update the document's groups\\n self._groups = self._root.findall('group') \\n print 'Creating group, \\\\'%s\\\\'' % name\\n return CAGroup(new_group)\",\n \"def ad_group_name(self):\\n\\n return self._ad_group_name\",\n \"def ad_group_name(self):\\n\\n return self._ad_group_name\",\n \"def _set_group_name(self):\\n self._scene_gen.group_name = self._group_name_le.text()\\n self._refresh_view()\",\n \"def make_group(self, id, name='', attrs={}, link='', abort=True ): \\n gid = id + \\\"/\\\"\\n sgd = self.get_sgd(gid, name)\\n path = self.full_path\\n link_info = self.file.extract_link_info(name, link, Group)\\n if not abort:\\n # id = sgd['id'].rstrip('/') # not sure if need this\\n grp = self.file.get_existing_group(path, id, name)\\n if grp:\\n return grp\\n grp = Group(self.file, sgd, name, path, attrs, self, link_info)\\n # self.mstats[gid]['created'].append(grp)\\n return grp\",\n \"def copy_group(self):\\n dd = self.destination_directory\\n sg = self.source_group\\n dg = self.destination_group\\n\\n data = {\\n 'description': sg.description,\\n 'name': sg.name,\\n 'status': sg.status,\\n }\\n\\n # If this Group already exists, we'll just update it.\\n if dg:\\n for key, value in data.items():\\n setattr(dg, key, value)\\n\\n while True:\\n try:\\n dg.save()\\n return dg\\n except StormpathError as err:\\n logger.error('Failed to copy Group: {} into Directory: {} ({})'.format(sg.name.encode('utf-8'), dd.name.encode('utf-8'), err))\\n\\n # If we get here, it means we need to create the Group from scratch.\\n while True:\\n try:\\n return dd.groups.create(data)\\n except StormpathError as err:\\n logger.error('Failed to copy Group: {} into Directory: {} ({})'.format(sg.name.encode('utf-8'), dd.name.encode('utf-8'), err))\",\n \"def condition_group_options(self):\\n if \\\"no-groups\\\" in self.options and self.options[\\\"no-groups\\\"]:\\n self.options[\\\"groups\\\"] = []\\n if \\\"exclude-groups\\\" in self.options:\\n del self.options[\\\"exclude-groups\\\"]\\n\\n return\\n\\n super().condition_group_options()\",\n \"def group_name(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"group_name\\\")\",\n \"def settings_group_options():\\n return [('', _('No group')), *[(str(a.id), str(a)) for a in Group.objects.all()]]\",\n \"def __str__(self):\\n\\n return 'Group(%s)' % self.id\",\n \"def create_placement_group(self, name, strategy='cluster'):\\r\\n params = {'GroupName':name, 'Strategy':strategy}\\r\\n group = self.get_status('CreatePlacementGroup', params, verb='POST')\\r\\n return group\",\n \"def create_new_group(self, a, b):\\n self.groups[self.group_id] = set([a,b])\\n self.node_id[a] = self.node_id[b] = self.group_id\\n self.group_id += 1\",\n \"def group(cls):\\n return relationship.many_to_one(cls, 'group')\",\n \"def _process_group(self, **config_kwargs) -> RobotGroupConfig:\\n return RobotGroupConfig(self.sim_scene, **config_kwargs)\",\n \"def group(*args, absolute: bool=True, empty: bool=True, name: AnyStr=\\\"\\\", parent: AnyStr=\\\"\\\",\\n relative: bool=True, useAsGroup: AnyStr=\\\"\\\", world: bool=True, **kwargs)->AnyStr:\\n pass\",\n \"def space_group(self) -> PermutationGroup:\\n return self._full_translation_group @ self.point_group\",\n \"def get_security_group_short_name(self):\\n return self.config['security_group']\",\n \"def add_bu_group(self, **kwargs):\\n _stringify_kw(kwargs)\\n \\n bu_group = ElementTree.Element(xml_strings['backup_group'], **kwargs)\\n self._root.append(bu_group)\\n return XMLGroupOverlay(bu_group, self._root)\",\n \"def get_grp_string(self):\\n\\n grp = self.get_grp()\\n\\n if grp == -1:\\n\\n return \\\"\\\"\\n\\n return \\\"grp \\\" + str(grp)\",\n \"def koie_group():\\n return GroupFactory(name=\\\"Koiene\\\")\",\n \"def append_groups(self, name, groups):\\r\\n self.__groups[name] = groups\",\n \"def autoCreateGroup(cleaned_data, cookie_user, isAutoApproved=False, querystring_content=False):\\n existingSites = Site.objects.filter(\\n domain=cleaned_data['domain'],\\n )\\n if len(existingSites) > 0:\\n\\n try:\\n site = existingSites[0]\\n group = site.group\\n except Exception, e:\\n raise Exception(\\\"Site \\\"+cleaned_data['domain']+\\\" has no group.\\\")\\n else:\\n # make a group and site\\n try:\\n group = Group.objects.create(\\n name=cleaned_data['name'],\\n short_name=cleaned_data['short_name'],\\n approved=False,\\n temp_interact=0,\\n requires_approval=False,\\n )\\n except Exception, e:\\n print \\\"* * * ** * * * * * * * EXCEPTION \\\"\\n print e\\n logger.warn(e)\\n groups = Group.objects.filter(\\n short_name=cleaned_data['short_name']\\n )\\n if len(groups) == 1:\\n group = groups[0]\\n elif len(groups) > 1:\\n raise Exception(\\\"More than one group with shortname found: \\\" + cleaned_data['short_name'])\\n else:\\n raise Exception(\\\"No groups found with shortname: \\\" + cleaned_data['short_name'])\\n\\n site = Site.objects.create(\\n name=cleaned_data['domain'],\\n domain=cleaned_data['domain'],\\n group=group,\\n # this is whether or not a querystring is counted in the url - we should rename this\\n querystring_content=querystring_content,\\n )\\n\\n blessed_tags = addDefaultsForNewGroup(group, cookie_user)\\n autoApproveUserAsAdmin(group, cookie_user, isAutoApproved=isAutoApproved)\\n\\n return group, site, blessed_tags\",\n \"def space_group(self, point_group: Optional[PointGroup] = None) -> PermutationGroup:\\n return self.space_group_builder(point_group).space_group\",\n \"def clone(self):\\n return _libsbml.Group_clone(self)\",\n \"def findGroup(self, name):\\n for g in self._groups:\\n if g.find('name').text.strip() == name:\\n return CAGroup(g)\\n \\n # If we are here the group does not exist\\n\\n g = ET.SubElement(self._root, 'group')\\n n = ET.SubElement(g, 'name')\\n n.text = name.strip()\\n return CAGroup(g)\",\n \"def create_group(self, name):\\n\\t\\tdata = {\\\"name\\\":name}\\n\\t\\tresponse = self.client.post(self._endpoint + \\\"/group\\\", content=data)\\n\\t\\treturn Group(\\n\\t\\t\\tresponse.json['group_id'],\\n\\t\\t\\tself.user_id,\\n\\t\\t\\tself.site_id,\\n\\t\\t\\tdata=response.json\\n\\t\\t)\",\n \"def log_group_name(self) -> typing.Optional[str]:\\n return self._values.get('log_group_name')\",\n \"def make_group(self, qid, name='', path='', attrs={}, link='', abort=True):\\n gqid = qid + \\\"/\\\"\\n sdef = self.get_sdef(gqid, self.default_ns, \\\"referenced in make_group\\\")\\n id = sdef['id']\\n ns = sdef['ns']\\n path = self.deduce_path(id, ns, path)\\n if not abort:\\n id_noslash = id.rstrip('/') # could be different from gqid if namespace present\\n grp = self.get_existing_group(path, id_noslash, name)\\n if grp:\\n # found already existing group\\n return grp \\n link_info = self.extract_link_info(name, link, Group)\\n # create the group\\n parent = None # no parent since this node created from File object (top level)\\n grp = Group(self, sdef, name, path, attrs, parent, link_info)\\n return grp\",\n \"def group(self):\\n return self.tr(self.groupId())\",\n \"def group(self):\\n return self.tr(self.groupId())\",\n \"def group(self):\\n return self.tr(self.groupId())\",\n \"def group(self):\\n return self.tr(self.groupId())\",\n \"def instance_group(self):\\n return self._instance_group\",\n \"def getGroupingStrategyFactory(self) -> cern.japc.core.spi.group.GroupSubscriptionStrategyFactory:\\n ...\",\n \"def __create_new_group(self, group_name) -> None:\\n group = Group(name=group_name)\\n group.save()\\n\\n self.__add_permission_to_group(group)\",\n \"def create_group(self, label):\\n group = OptionGroup(label)\\n self.append(group)\\n return group\",\n \"def create_group(self):\\n # TODO: Assuming first server is good - need to make fallback logic\\n return self.session.get_any(\\\"{base}{request_url}\\\".format(base=self.servers[0],\\n request_url=F\\\"/GroupV2/Create/\\\"))\",\n \"def group(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"group\\\")\",\n \"def group(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"group\\\")\",\n \"def group(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"group\\\")\",\n \"def log_group_name(self) -> str:\\n ...\",\n \"def create_group(self, name, track_order=False):\\n full_name = self._get_h5_path(name)\\n with open_hdf5(self.file_name, mode=\\\"a\\\") as h:\\n try:\\n h.create_group(full_name, track_order=track_order)\\n except ValueError:\\n pass\\n h_new = self[name].copy()\\n return h_new\",\n \"def placement_group(template, name):\\n p = PlacementGroup(name, template=template)\\n p.Strategy = 'cluster'\\n return p\",\n \"def get_joining_group_property(value, limit_ascii=False):\\n\\n obj = unidata.ascii_joining_group if limit_ascii else unidata.unicode_joining_group\\n\\n if value.startswith('^'):\\n negated = value[1:]\\n value = '^' + unidata.unicode_alias['joininggroup'].get(negated, negated)\\n else:\\n value = unidata.unicode_alias['joininggroup'].get(value, value)\\n\\n return obj[value]\",\n \"def register_group(self, cls):\\n return self.register_entity('group', cls)\",\n \"def group_settings_greedy(obs_expt: ObservablesExperiment):\\n diag_sets = _max_tpb_overlap(obs_expt)\\n grouped_expt_settings_list = list(diag_sets.values())\\n grouped_obs_expt = ObservablesExperiment(grouped_expt_settings_list, program=obs_expt.program)\\n return grouped_obs_expt\",\n \"def clean_group_name(self):\\r\\n group_name = self.cleaned_data['group_name']\\r\\n master_id = 0\\r\\n\\r\\n if self.instance:\\r\\n # master id is used to exclude current master so that it is not checked as duplicate\\r\\n master_id = self.instance.id\\r\\n\\r\\n if LedgerGroup.objects.filter(company=self.company, group_name__iexact=group_name).exclude(id=master_id).exists():\\r\\n raise forms.ValidationError(\\\"Group name already exists\\\")\\r\\n\\r\\n return group_name\",\n \"def setGroup(self, group):\\n\\t\\tself.config.GROUP = group\",\n \"def reserve_group(self, name, sco):\\n\\t\\tif self.client is None:\\n\\t\\t\\traise UsageError(\\\"Not connected!\\\")\\n\\t\\treturn self.client.reserve_group(name, sco)\",\n \"def test_save(self, name='test'):\\n group = Group(name=name)\\n group.save()\\n return group\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6209012","0.5984325","0.5788384","0.568222","0.56628835","0.563917","0.5622585","0.56192756","0.56191015","0.55996215","0.5569049","0.5563115","0.5557951","0.55311483","0.550896","0.54411197","0.54324687","0.5423106","0.5397997","0.53885156","0.53813946","0.53632164","0.53505796","0.5339749","0.5275209","0.5269216","0.526579","0.5263766","0.52470654","0.521963","0.52088445","0.5176984","0.5169597","0.515446","0.51513135","0.51204866","0.5120229","0.51128656","0.51046693","0.5103994","0.51027495","0.5097854","0.5097854","0.5097854","0.50927633","0.50817597","0.50773007","0.50773007","0.50755256","0.50755256","0.5064863","0.50646526","0.50646526","0.50474006","0.5038595","0.503742","0.5025156","0.5020198","0.5001938","0.49956775","0.49760523","0.49579725","0.49555078","0.49529397","0.49523017","0.49281657","0.4927576","0.492138","0.49213234","0.49208438","0.4916125","0.49143296","0.4910319","0.4909751","0.49063545","0.49046493","0.4890871","0.48863885","0.48816508","0.48816508","0.48816508","0.48816508","0.4879832","0.48770487","0.4856341","0.48561046","0.48540485","0.48439813","0.48439813","0.48439813","0.48400763","0.48337492","0.4824906","0.48225257","0.48182976","0.48049164","0.47935003","0.47884715","0.47748235","0.47719073"],"string":"[\n \"0.6209012\",\n \"0.5984325\",\n \"0.5788384\",\n \"0.568222\",\n \"0.56628835\",\n \"0.563917\",\n \"0.5622585\",\n \"0.56192756\",\n \"0.56191015\",\n \"0.55996215\",\n \"0.5569049\",\n \"0.5563115\",\n \"0.5557951\",\n \"0.55311483\",\n \"0.550896\",\n \"0.54411197\",\n \"0.54324687\",\n \"0.5423106\",\n \"0.5397997\",\n \"0.53885156\",\n \"0.53813946\",\n \"0.53632164\",\n \"0.53505796\",\n \"0.5339749\",\n \"0.5275209\",\n \"0.5269216\",\n \"0.526579\",\n \"0.5263766\",\n \"0.52470654\",\n \"0.521963\",\n \"0.52088445\",\n \"0.5176984\",\n \"0.5169597\",\n \"0.515446\",\n \"0.51513135\",\n \"0.51204866\",\n \"0.5120229\",\n \"0.51128656\",\n \"0.51046693\",\n \"0.5103994\",\n \"0.51027495\",\n \"0.5097854\",\n \"0.5097854\",\n \"0.5097854\",\n \"0.50927633\",\n \"0.50817597\",\n \"0.50773007\",\n \"0.50773007\",\n \"0.50755256\",\n \"0.50755256\",\n \"0.5064863\",\n \"0.50646526\",\n \"0.50646526\",\n \"0.50474006\",\n \"0.5038595\",\n \"0.503742\",\n \"0.5025156\",\n \"0.5020198\",\n \"0.5001938\",\n \"0.49956775\",\n \"0.49760523\",\n \"0.49579725\",\n \"0.49555078\",\n \"0.49529397\",\n \"0.49523017\",\n \"0.49281657\",\n \"0.4927576\",\n \"0.492138\",\n \"0.49213234\",\n \"0.49208438\",\n \"0.4916125\",\n \"0.49143296\",\n \"0.4910319\",\n \"0.4909751\",\n \"0.49063545\",\n \"0.49046493\",\n \"0.4890871\",\n \"0.48863885\",\n \"0.48816508\",\n \"0.48816508\",\n \"0.48816508\",\n \"0.48816508\",\n \"0.4879832\",\n \"0.48770487\",\n \"0.4856341\",\n \"0.48561046\",\n \"0.48540485\",\n \"0.48439813\",\n \"0.48439813\",\n \"0.48439813\",\n \"0.48400763\",\n \"0.48337492\",\n \"0.4824906\",\n \"0.48225257\",\n \"0.48182976\",\n \"0.48049164\",\n \"0.47935003\",\n \"0.47884715\",\n \"0.47748235\",\n \"0.47719073\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5727455"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":3192,"cells":{"query":{"kind":"string","value":"Return a list of all groups under the current group. (This is potentially slow, as it recomputes every time.)"},"document":{"kind":"string","value":"def getChildGroups(self):\n\t\tgroupPrefix = self.__DELIMITER.join(self.__currentGroupNames)\n\t\tif groupPrefix:\n\t\t\tgroupPrefix += self.__DELIMITER\n\t\tskipLen = len(groupPrefix)\n\t\tchildGroups = set()\n\t\tfor keyName in self.__settings.keys():\n\t\t\tif keyName.startswith(groupPrefix):\n\t\t\t\tchildKey = keyName[skipLen:]\n\t\t\t\tgroupKey, _, grandChildKey = \\\n\t\t\t\t\tchildKey.partition(self.__DELIMITER)\n\t\t\t\tif grandChildKey:\n\t\t\t\t\tchildGroups.add(groupKey)\n\t\treturn filter(bool, childGroups)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getGroups(self):\n return [g[0] for g in grp.getgrall()]","def list_groups():\n return _list_tindyb_unique_values(\"group\", dbpath=__dbpath__)","def get_all_groups(self):\n return self.groups + ['all']","def getGroups():\r\n return Group.getGroups()","def get_pingroups(self):\n return self.groups[:]","def all_groups(self):\n return self._all_groups","def iter_groups(self):\n\t\treturn iter(self._groups)","def groups(self):\n return []","def get_groups(self):\n user_node = self.get()\n grouplist = []\n if user_node:\n for rel in graph.match(start_node=user_node, rel_type='in'):\n grouplist.append(Usergroup(id=rel.end_node()['id']))\n return grouplist","def groups(self):\n return self._groups","def groups(self):\n return self._groups","def groups(self):\n return self._groups","def get_all_groups(self):\n self.cursor.execute(\"select * from groups\")\n self.connection.commit()\n return self.cursor.fetchall()","def groups(self):\n return self.get_data(\"groups\")","def get_group_names(self):\r\n return self.groups.keys()","def list_all_groups(self):\n groups = set()\n [groups.update(x) for x in self._groups.values()]\n return groups","def get_groups(self):\n return [self.primary_group] + list(self.secondary_groups)","def groups(self):\n #return self.get('{}/groups'.format(ApiVersion.A1.value))\n return self.get('{}/groups'.format(ApiVersion.CM1.value))","def groups(self):\n # type: (...) -> Set[str]\n return self._groups","def get_groups(self):\n return Client._get(self)","def groups(self):\n yield self\n for member_group in self._groups():\n yield member_group","def list_groups(args):\n\n for group in get_groups(args):\n print(group)","def find_groups(self, mesh):\n grp_names = []\n for grp in self._grps.values():\n grp_names.extend(grp.find_groups(mesh))\n return grp_names","def groups(self):\r\n return resources.Groups(self)","def all_groups(parent=None):\n if parent is None:\n parent = QgsProject.instance().layerTreeRoot()\n\n def do_a_group(grp, level=0):\n for child in grp.children():\n if isinstance(child, QgsLayerTreeGroup):\n yield child\n do_a_group(child, level=level + 1)\n\n do_a_group(parent)","def list_groups(self):\n return self.get_admin(\"groups\")","def getListOfGroups(self, *args):\n return _libsbml.GroupsModelPlugin_getListOfGroups(self, *args)","def get_list_groups(self):\n list_response = requests.get(self.groups_url, headers=self.headers)\n return list_response.json()[\"groups\"]","def get_groups(self, username):\n groups = []\n for group in grp.getgrall():\n if username in group.gr_mem:\n groups.append(group.gr_name)\n\n return groups","def groups(self):\r\n return users.Groups(self)","def groupby(self):\n try:\n return plist([x.groupby() for x in self])\n except Exception:\n groups = collections.OrderedDict()\n for i, x in enumerate(self):\n if x not in groups:\n groups[x] = plist()\n groups[x].append(self.__root__[i])\n return plist(groups.values())","def get_group_list(self):\n return [(item[0], item[1][0]) for item in self.contacts_by_group_list]","def get_groups(self, group_name):\r\n assert group_name in self.groups.keys(), group_name\r\n try:\r\n group_list = self.groups[group_name]\r\n except KeyError:\r\n raise GroupKeyError()\r\n return group_list","def get(self, *args):\n return _libsbml.ListOfGroups_get(self, *args)","def groups(self) -> list[Group]:\n return self._connection.groups","def GetAncestorGroups(self):\n return [node for node in self.GetAncestors() if node.IsGroup()]","def group(self):\n instances = self.instances\n groups = []\n for i in range(len(self.labels)):\n groups.append([instance for instance in instances if instance[-1] == self.labels[i]])\n return groups","def get_groups(self, obj):\n groupsForCompany = get_groups_with_perms(obj)\n return [x.id for x in groupsForCompany]","def get_group(tkn: Token = Depends(from_authotization_header_nondyn),):\n assert_has_clearance(tkn.owner, \"sni.read_group\")\n return [\n GetGroupShortOut(group_id=str(grp.pk), group_name=grp.group_name)\n for grp in Group.objects().order_by(\"group_name\")\n ]","def get_groups(self):\n\n if not self.check_prereqs():\n raise StopIteration\n\n db = self.env.get_db_cnx()\n cursor = db.cursor()\n\n query=self.create_query(self.sql_get_groups_query+\" ORDER BY $groupname_field$\",{'groupname_field':self.sql_groupname_field})\n self.log.debug(\"sqlflexibleauthstore: get_groups: %s\" % (query,))\n\n cursor.execute(query)\n desc=[i[0] for i in cursor.description]\n for row in cursor:\n dictrow=dict(zip(desc,row))\n yield dictrow[self.sql_groupname_field]","def list_group():\n data, code, message = FIELD_SERVICE.list_group()\n return __result(data, code, message)","def GetGroupMembers(self, group):\n return []","def find_groups(self, mesh):\n grps = []\n dim = mesh.give_dim()\n if dim:\n ctypes = self._dct[dim]\n grps = self._exp.find_groups_from_ctypes(mesh, ctypes)\n log.debug(\"GroupExplorator.find_groups for mesh %s returns %s with dim %s and dct %s\", mesh, grps, dim, self._dct)\n return grps","def GetGroupList(setting):\n groups = set()\n\n for name in setting:\n dev = setting[name]\n format_, group = GetFieldDef(dev, fields=\"format_, group\")\n if group is not None and len(group) > 0:\n groups.add(group.title())\n if isinstance(format_, dict):\n subgroups = GetGroupList(format_)\n if subgroups is not None and len(subgroups) > 0:\n for group in subgroups:\n groups.add(group.title())\n\n groups=list(groups)\n groups.sort()\n return groups","async def get_groups(self) -> list:\n results = await self._api.call('group', 'get_groups')\n return [models.Group(grp) for grp in results.payload]","def getGroup():\n\tprint\n\tprint \"Requesting the list of groups for this account\"\n\n\tgroups_result = getResult('/papi/v0/groups')\n\n\treturn (groups_result)","def groups():\n access_token = session['access_token']\n return \"%s\" % list_groups(access_token)","def getPeopleGroups(self):\n return [FoursquarePeopleGroup(le) for le in self.base.get(\"groups\", [])]","def groupfinder(name, request):\n #FIXME: Implement\n return ()\n return request.context.get_groups(name)","def get_group_list(self) -> Sequence[str]:\n return [group.Name.lower() for group in self.LedGroups]","def get_groups(self):\n response = self._get(\"groups\")\n\n return response.json()","def groups(self):\n new = self.copy()\n new._filter = [\"groups\"]\n return new","def get_groups_for_current_user():\n return UserAPI.get_groups_for_user_id(current_user)","def get_groups(self):\n result = self.conn.usergroup.get(status=0, output='extend', selectUsers=\"extend\")\n groups = {group[\"name\"]: Group(\n name=group[\"name\"],\n id=group[\"usrgrpid\"],\n members=group[\"users\"],\n ) for group in result}\n return groups","def list_group(self, groupname):\n return self.get_admin(\"groups/{}\".format(groupname))","def groups(self, deep=False, exclude_prefix=None):\n\n for group in self._groups:\n if exclude_prefix is None or not group.startswith(exclude_prefix):\n yield group\n if deep:\n yield from (group + \"/\" + subgroup\n for subgroup in self[group].groups(deep))","def get_groups(self, principal):\n groups = set()\n for location in lineage(self):\n location_groups = location._groups\n try:\n if self is location:\n groups.update(location_groups[principal])\n else:\n groups.update([x for x in location_groups[principal]])\n except KeyError:\n continue\n\n return tuple(groups)","def grouplist(self, namespace=None):\n source = self._source(namespace)\n return self._list(source, 'list')","def get_all_as_groups(as_connection):\n as_groups_list = []\n get_as_groups = as_connection.get_all_groups()\n as_groups_list.extend(get_as_groups)\n\n token = get_as_groups.next_token\n while token is not None:\n get_as_groups = as_connection.get_all_groups(\n next_token=token)\n as_groups_list.extend(get_as_groups)\n token = get_as_groups.next_token\n print \"Processed {0} AutoScaling Group\"\\\n .format(len(as_groups_list))\n return as_groups_list","def get_all_patents(self):\n return list(self._groups_groupby_patent.groups.keys())","def get_all(isamAppliance, check_mode=False, force=False):\n return isamAppliance.invoke_get(\"Retrieving groups\", \"/sysaccount/groups/v1\")","def listGroups(self):\n return tuple(Group.create(groupName, self._modelDataManager) for groupName in self.pm_getUserManager().listGroups())","def get_all_events_by_group() -> Group:\n level = Event.objects.filter(level__contains='information').values_list('agent')\n agent = Agent.objects.filter(pk__in=level).values_list('user')\n user = User.objects.filter(pk__in=agent).values_list('group')\n return Group.objects.filter(pk__in=user)","def refreshGroups(self):\n self.groups = []\n\n self.addGroupsWithIds(self._getGroupIdsJoined())\n self.addGroupsWithIds(self._getGroupIdsInvited(), False)","def get_all_groups():\n return jsonify(admin.get_all_groups(current_app.scoped_session()))","def get_groups(self) -> dict:\n return dict(self._groups)","def get_item_groups(dataset):\n return dataset.groupby(\"name\", as_index=False, sort=False).groups","def pull_all_rhds_group(self):\n return self.ldap_connection.search_s(\"ou=managedGroups,dc=redhat,dc=com\",\n ldap.SCOPE_SUBTREE)","def ObjectGroups(object_id):\n rhino_object = rhutil.coercerhinoobject(object_id, True, True)\n if rhino_object.GroupCount<1: return []\n group_indices = rhino_object.GetGroupList()\n rc = [scriptcontext.doc.Groups.GroupName(index) for index in group_indices]\n return rc","def get_relevant_perm_groups(self):\n\n groups = Group.objects.filter(Q(name=\"everyone\") | Q(name=self.admin_group_name()) | Q(name=self.participants_group_name()))\n return groups","def get_current_grp():\n return get_group_grp(os.getgid())","def get_groups(nodes):\n return list(set([node.color for node in nodes]))","def get_groups(id_project):\n data = sql.list_groups(id_project)\n names = [(d['id'], d['name']) for d in data]\n return names","def _get_check_groups(self, group=None):\n groups = [g for g in self.config_dict]\n if group:\n if group in groups:\n check_groups = [group]\n else:\n check_groups = []\n else:\n check_groups = groups\n return check_groups","def get_groups(self, username):\n return []","def output_groups(self) -> List[str]:\n return self._output_groups","def getUserGroups(self, user):\n return [gu[0] for gu in grp.getgrall() if user in gu[3]]","def global_node_groups(self) -> pulumi.Output[Sequence['outputs.GlobalReplicationGroupGlobalNodeGroup']]:\n return pulumi.get(self, \"global_node_groups\")","def list_groups(self, **params):\n url = 'groups'\n if params:\n url += '?%s' % urllib.urlencode(params)\n resp, body = self.get(url)\n self.expected_success(200, resp.status)\n body = json.loads(body)\n return rest_client.ResponseBody(resp, body)","def get_all_nda(self):\n return list(self._groups_groupby_NDA.groups.keys())","def pull_groups(self, org):\n pass","def _complete_groups(self, text):\r\n groups = []\r\n for info in self._get_complete_info():\r\n if info['group'] not in groups:\r\n groups.append(info['group'])\r\n return [ g + ' ' for g in groups if g.startswith(text) ]","def get_groups(self, cell: Cell) -> Set[Group]:\n\t\tassert cell in self._cells\n\t\treturn self._cells_to_group_map[cell]","def get_nested_groups(self, conn, group: str) -> typing.List[str]:\n nested_groups = list()\n conn.search(\n search_base=self.group_search_base,\n search_filter=self.group_search_filter.format(group=group),\n search_scope=ldap3.SUBTREE)\n if conn.response:\n for nested_group in conn.response:\n if 'dn' in nested_group:\n nested_groups.extend([nested_group['dn']])\n groups = self.get_nested_groups(conn, nested_group['dn'])\n nested_groups.extend(groups)\n nested_groups = list(set(nested_groups))\n return nested_groups","def get_group_list(org_id):\n tList = get_template('app/usermanagementorg/group_list.html')\n groups = get_groups(org_id)\n return tList.render(Context({ 'groups': groups, }))","def __iter__(self):\n try:\n groupNames = sorted(self.groups)\n except Exception: # pragma: no cover\n groupNames = self.groups.keys()\n\n for groupName in groupNames:\n yield groupName, self[groupName]","def get(self):\r\n return UserGroupService.getAllUserGroups(self)","def groupsChanged(self):\n # Get the list of groups for the present user according to\n # the checklist.\n nglist = []\n for r in self.liststore:\n if (r[1] and (r[0] != self.gidnm)):\n nglist.append(r[0])\n if (gui.getUserGroups(gui.currentUser) != nglist):\n return nglist\n else:\n return None","def path_groups(self):\n return self._path_groups","def get_all_groups(self, account_name=None, account_id=None, path=None, group_name=None,\n group_id=None, search=False ):\n grouplist=[]\n accounts = self.get_all_accounts(account_id=account_id, account_name=account_name,\n search=search)\n for account in accounts:\n groups = self.get_groups_from_account(path=path,\n group_name=group_name,\n group_id=group_id,\n delegate_account=account['account_name'],\n search=search)\n for group in groups:\n group['account_name']=account['account_name']\n group['account_id']=account['account_id']\n grouplist.append(group)\n return grouplist","def get_groups():\n\n groups = [\"shelter\", \"sharing\", \"unsheltered\", \"motel\"]\n\n for item in groups:\n group = Group(group_name=item)\n\n db.session.add(group)\n\n db.session.commit()","def get_all():\n\n return AGE_GROUPS","def getGroups(self, proteinId):\n return [self.groups[gId] for gId in self._proteinToGroupIds[proteinId]]","def running_groups(self):\n return set(\n cmd.group_by for id, cmd in self.commands\n if cmd.is_running and cmd.group_by is not None\n )","def get_all_groups(self, path_prefix='/', marker=None, max_items=None):\r\n params = {}\r\n if path_prefix:\r\n params['PathPrefix'] = path_prefix\r\n if marker:\r\n params['Marker'] = marker\r\n if max_items:\r\n params['MaxItems'] = max_items\r\n return self.get_response('ListGroups', params,\r\n list_marker='Groups')","def group_nodes(self, group, namespace=None):\n source = self._source(namespace)\n return self._list(source, 'map', group)","def getGroup(group: int, name=\"\") -> list:\n groups = mongo.db.groups.find({'id':group},{'_id':0})\n userID_list = []\n user_list = []\n for entry in groups:\n if entry[\"id\"] == group:\n userID_list = userID_list + entry[\"members\"]\n if len(userID_list) != 0:\n for entry in userID_list:\n x = fetchUser(userId=entry)\n user_list = user_list + x\n return user_list","def granted_groups(self):\n return [\n g\n for g in Group.objects.filter()\n if ManagedObject.objects.filter(GroupAccess.Q(g) & Q(id=self.id)).exists()\n ]","def fusion_api_get_directory_groups(self, body, api=None, headers=None):\n return self.logindomain.groups(body, api, headers)","def readGroups(self):\n\t\tgroups = self._fileSystem.readGroups()\n\t\tif groups is None:\n\t\t\treturn\n\t\treturn groups"],"string":"[\n \"def getGroups(self):\\n return [g[0] for g in grp.getgrall()]\",\n \"def list_groups():\\n return _list_tindyb_unique_values(\\\"group\\\", dbpath=__dbpath__)\",\n \"def get_all_groups(self):\\n return self.groups + ['all']\",\n \"def getGroups():\\r\\n return Group.getGroups()\",\n \"def get_pingroups(self):\\n return self.groups[:]\",\n \"def all_groups(self):\\n return self._all_groups\",\n \"def iter_groups(self):\\n\\t\\treturn iter(self._groups)\",\n \"def groups(self):\\n return []\",\n \"def get_groups(self):\\n user_node = self.get()\\n grouplist = []\\n if user_node:\\n for rel in graph.match(start_node=user_node, rel_type='in'):\\n grouplist.append(Usergroup(id=rel.end_node()['id']))\\n return grouplist\",\n \"def groups(self):\\n return self._groups\",\n \"def groups(self):\\n return self._groups\",\n \"def groups(self):\\n return self._groups\",\n \"def get_all_groups(self):\\n self.cursor.execute(\\\"select * from groups\\\")\\n self.connection.commit()\\n return self.cursor.fetchall()\",\n \"def groups(self):\\n return self.get_data(\\\"groups\\\")\",\n \"def get_group_names(self):\\r\\n return self.groups.keys()\",\n \"def list_all_groups(self):\\n groups = set()\\n [groups.update(x) for x in self._groups.values()]\\n return groups\",\n \"def get_groups(self):\\n return [self.primary_group] + list(self.secondary_groups)\",\n \"def groups(self):\\n #return self.get('{}/groups'.format(ApiVersion.A1.value))\\n return self.get('{}/groups'.format(ApiVersion.CM1.value))\",\n \"def groups(self):\\n # type: (...) -> Set[str]\\n return self._groups\",\n \"def get_groups(self):\\n return Client._get(self)\",\n \"def groups(self):\\n yield self\\n for member_group in self._groups():\\n yield member_group\",\n \"def list_groups(args):\\n\\n for group in get_groups(args):\\n print(group)\",\n \"def find_groups(self, mesh):\\n grp_names = []\\n for grp in self._grps.values():\\n grp_names.extend(grp.find_groups(mesh))\\n return grp_names\",\n \"def groups(self):\\r\\n return resources.Groups(self)\",\n \"def all_groups(parent=None):\\n if parent is None:\\n parent = QgsProject.instance().layerTreeRoot()\\n\\n def do_a_group(grp, level=0):\\n for child in grp.children():\\n if isinstance(child, QgsLayerTreeGroup):\\n yield child\\n do_a_group(child, level=level + 1)\\n\\n do_a_group(parent)\",\n \"def list_groups(self):\\n return self.get_admin(\\\"groups\\\")\",\n \"def getListOfGroups(self, *args):\\n return _libsbml.GroupsModelPlugin_getListOfGroups(self, *args)\",\n \"def get_list_groups(self):\\n list_response = requests.get(self.groups_url, headers=self.headers)\\n return list_response.json()[\\\"groups\\\"]\",\n \"def get_groups(self, username):\\n groups = []\\n for group in grp.getgrall():\\n if username in group.gr_mem:\\n groups.append(group.gr_name)\\n\\n return groups\",\n \"def groups(self):\\r\\n return users.Groups(self)\",\n \"def groupby(self):\\n try:\\n return plist([x.groupby() for x in self])\\n except Exception:\\n groups = collections.OrderedDict()\\n for i, x in enumerate(self):\\n if x not in groups:\\n groups[x] = plist()\\n groups[x].append(self.__root__[i])\\n return plist(groups.values())\",\n \"def get_group_list(self):\\n return [(item[0], item[1][0]) for item in self.contacts_by_group_list]\",\n \"def get_groups(self, group_name):\\r\\n assert group_name in self.groups.keys(), group_name\\r\\n try:\\r\\n group_list = self.groups[group_name]\\r\\n except KeyError:\\r\\n raise GroupKeyError()\\r\\n return group_list\",\n \"def get(self, *args):\\n return _libsbml.ListOfGroups_get(self, *args)\",\n \"def groups(self) -> list[Group]:\\n return self._connection.groups\",\n \"def GetAncestorGroups(self):\\n return [node for node in self.GetAncestors() if node.IsGroup()]\",\n \"def group(self):\\n instances = self.instances\\n groups = []\\n for i in range(len(self.labels)):\\n groups.append([instance for instance in instances if instance[-1] == self.labels[i]])\\n return groups\",\n \"def get_groups(self, obj):\\n groupsForCompany = get_groups_with_perms(obj)\\n return [x.id for x in groupsForCompany]\",\n \"def get_group(tkn: Token = Depends(from_authotization_header_nondyn),):\\n assert_has_clearance(tkn.owner, \\\"sni.read_group\\\")\\n return [\\n GetGroupShortOut(group_id=str(grp.pk), group_name=grp.group_name)\\n for grp in Group.objects().order_by(\\\"group_name\\\")\\n ]\",\n \"def get_groups(self):\\n\\n if not self.check_prereqs():\\n raise StopIteration\\n\\n db = self.env.get_db_cnx()\\n cursor = db.cursor()\\n\\n query=self.create_query(self.sql_get_groups_query+\\\" ORDER BY $groupname_field$\\\",{'groupname_field':self.sql_groupname_field})\\n self.log.debug(\\\"sqlflexibleauthstore: get_groups: %s\\\" % (query,))\\n\\n cursor.execute(query)\\n desc=[i[0] for i in cursor.description]\\n for row in cursor:\\n dictrow=dict(zip(desc,row))\\n yield dictrow[self.sql_groupname_field]\",\n \"def list_group():\\n data, code, message = FIELD_SERVICE.list_group()\\n return __result(data, code, message)\",\n \"def GetGroupMembers(self, group):\\n return []\",\n \"def find_groups(self, mesh):\\n grps = []\\n dim = mesh.give_dim()\\n if dim:\\n ctypes = self._dct[dim]\\n grps = self._exp.find_groups_from_ctypes(mesh, ctypes)\\n log.debug(\\\"GroupExplorator.find_groups for mesh %s returns %s with dim %s and dct %s\\\", mesh, grps, dim, self._dct)\\n return grps\",\n \"def GetGroupList(setting):\\n groups = set()\\n\\n for name in setting:\\n dev = setting[name]\\n format_, group = GetFieldDef(dev, fields=\\\"format_, group\\\")\\n if group is not None and len(group) > 0:\\n groups.add(group.title())\\n if isinstance(format_, dict):\\n subgroups = GetGroupList(format_)\\n if subgroups is not None and len(subgroups) > 0:\\n for group in subgroups:\\n groups.add(group.title())\\n\\n groups=list(groups)\\n groups.sort()\\n return groups\",\n \"async def get_groups(self) -> list:\\n results = await self._api.call('group', 'get_groups')\\n return [models.Group(grp) for grp in results.payload]\",\n \"def getGroup():\\n\\tprint\\n\\tprint \\\"Requesting the list of groups for this account\\\"\\n\\n\\tgroups_result = getResult('/papi/v0/groups')\\n\\n\\treturn (groups_result)\",\n \"def groups():\\n access_token = session['access_token']\\n return \\\"%s\\\" % list_groups(access_token)\",\n \"def getPeopleGroups(self):\\n return [FoursquarePeopleGroup(le) for le in self.base.get(\\\"groups\\\", [])]\",\n \"def groupfinder(name, request):\\n #FIXME: Implement\\n return ()\\n return request.context.get_groups(name)\",\n \"def get_group_list(self) -> Sequence[str]:\\n return [group.Name.lower() for group in self.LedGroups]\",\n \"def get_groups(self):\\n response = self._get(\\\"groups\\\")\\n\\n return response.json()\",\n \"def groups(self):\\n new = self.copy()\\n new._filter = [\\\"groups\\\"]\\n return new\",\n \"def get_groups_for_current_user():\\n return UserAPI.get_groups_for_user_id(current_user)\",\n \"def get_groups(self):\\n result = self.conn.usergroup.get(status=0, output='extend', selectUsers=\\\"extend\\\")\\n groups = {group[\\\"name\\\"]: Group(\\n name=group[\\\"name\\\"],\\n id=group[\\\"usrgrpid\\\"],\\n members=group[\\\"users\\\"],\\n ) for group in result}\\n return groups\",\n \"def list_group(self, groupname):\\n return self.get_admin(\\\"groups/{}\\\".format(groupname))\",\n \"def groups(self, deep=False, exclude_prefix=None):\\n\\n for group in self._groups:\\n if exclude_prefix is None or not group.startswith(exclude_prefix):\\n yield group\\n if deep:\\n yield from (group + \\\"/\\\" + subgroup\\n for subgroup in self[group].groups(deep))\",\n \"def get_groups(self, principal):\\n groups = set()\\n for location in lineage(self):\\n location_groups = location._groups\\n try:\\n if self is location:\\n groups.update(location_groups[principal])\\n else:\\n groups.update([x for x in location_groups[principal]])\\n except KeyError:\\n continue\\n\\n return tuple(groups)\",\n \"def grouplist(self, namespace=None):\\n source = self._source(namespace)\\n return self._list(source, 'list')\",\n \"def get_all_as_groups(as_connection):\\n as_groups_list = []\\n get_as_groups = as_connection.get_all_groups()\\n as_groups_list.extend(get_as_groups)\\n\\n token = get_as_groups.next_token\\n while token is not None:\\n get_as_groups = as_connection.get_all_groups(\\n next_token=token)\\n as_groups_list.extend(get_as_groups)\\n token = get_as_groups.next_token\\n print \\\"Processed {0} AutoScaling Group\\\"\\\\\\n .format(len(as_groups_list))\\n return as_groups_list\",\n \"def get_all_patents(self):\\n return list(self._groups_groupby_patent.groups.keys())\",\n \"def get_all(isamAppliance, check_mode=False, force=False):\\n return isamAppliance.invoke_get(\\\"Retrieving groups\\\", \\\"/sysaccount/groups/v1\\\")\",\n \"def listGroups(self):\\n return tuple(Group.create(groupName, self._modelDataManager) for groupName in self.pm_getUserManager().listGroups())\",\n \"def get_all_events_by_group() -> Group:\\n level = Event.objects.filter(level__contains='information').values_list('agent')\\n agent = Agent.objects.filter(pk__in=level).values_list('user')\\n user = User.objects.filter(pk__in=agent).values_list('group')\\n return Group.objects.filter(pk__in=user)\",\n \"def refreshGroups(self):\\n self.groups = []\\n\\n self.addGroupsWithIds(self._getGroupIdsJoined())\\n self.addGroupsWithIds(self._getGroupIdsInvited(), False)\",\n \"def get_all_groups():\\n return jsonify(admin.get_all_groups(current_app.scoped_session()))\",\n \"def get_groups(self) -> dict:\\n return dict(self._groups)\",\n \"def get_item_groups(dataset):\\n return dataset.groupby(\\\"name\\\", as_index=False, sort=False).groups\",\n \"def pull_all_rhds_group(self):\\n return self.ldap_connection.search_s(\\\"ou=managedGroups,dc=redhat,dc=com\\\",\\n ldap.SCOPE_SUBTREE)\",\n \"def ObjectGroups(object_id):\\n rhino_object = rhutil.coercerhinoobject(object_id, True, True)\\n if rhino_object.GroupCount<1: return []\\n group_indices = rhino_object.GetGroupList()\\n rc = [scriptcontext.doc.Groups.GroupName(index) for index in group_indices]\\n return rc\",\n \"def get_relevant_perm_groups(self):\\n\\n groups = Group.objects.filter(Q(name=\\\"everyone\\\") | Q(name=self.admin_group_name()) | Q(name=self.participants_group_name()))\\n return groups\",\n \"def get_current_grp():\\n return get_group_grp(os.getgid())\",\n \"def get_groups(nodes):\\n return list(set([node.color for node in nodes]))\",\n \"def get_groups(id_project):\\n data = sql.list_groups(id_project)\\n names = [(d['id'], d['name']) for d in data]\\n return names\",\n \"def _get_check_groups(self, group=None):\\n groups = [g for g in self.config_dict]\\n if group:\\n if group in groups:\\n check_groups = [group]\\n else:\\n check_groups = []\\n else:\\n check_groups = groups\\n return check_groups\",\n \"def get_groups(self, username):\\n return []\",\n \"def output_groups(self) -> List[str]:\\n return self._output_groups\",\n \"def getUserGroups(self, user):\\n return [gu[0] for gu in grp.getgrall() if user in gu[3]]\",\n \"def global_node_groups(self) -> pulumi.Output[Sequence['outputs.GlobalReplicationGroupGlobalNodeGroup']]:\\n return pulumi.get(self, \\\"global_node_groups\\\")\",\n \"def list_groups(self, **params):\\n url = 'groups'\\n if params:\\n url += '?%s' % urllib.urlencode(params)\\n resp, body = self.get(url)\\n self.expected_success(200, resp.status)\\n body = json.loads(body)\\n return rest_client.ResponseBody(resp, body)\",\n \"def get_all_nda(self):\\n return list(self._groups_groupby_NDA.groups.keys())\",\n \"def pull_groups(self, org):\\n pass\",\n \"def _complete_groups(self, text):\\r\\n groups = []\\r\\n for info in self._get_complete_info():\\r\\n if info['group'] not in groups:\\r\\n groups.append(info['group'])\\r\\n return [ g + ' ' for g in groups if g.startswith(text) ]\",\n \"def get_groups(self, cell: Cell) -> Set[Group]:\\n\\t\\tassert cell in self._cells\\n\\t\\treturn self._cells_to_group_map[cell]\",\n \"def get_nested_groups(self, conn, group: str) -> typing.List[str]:\\n nested_groups = list()\\n conn.search(\\n search_base=self.group_search_base,\\n search_filter=self.group_search_filter.format(group=group),\\n search_scope=ldap3.SUBTREE)\\n if conn.response:\\n for nested_group in conn.response:\\n if 'dn' in nested_group:\\n nested_groups.extend([nested_group['dn']])\\n groups = self.get_nested_groups(conn, nested_group['dn'])\\n nested_groups.extend(groups)\\n nested_groups = list(set(nested_groups))\\n return nested_groups\",\n \"def get_group_list(org_id):\\n tList = get_template('app/usermanagementorg/group_list.html')\\n groups = get_groups(org_id)\\n return tList.render(Context({ 'groups': groups, }))\",\n \"def __iter__(self):\\n try:\\n groupNames = sorted(self.groups)\\n except Exception: # pragma: no cover\\n groupNames = self.groups.keys()\\n\\n for groupName in groupNames:\\n yield groupName, self[groupName]\",\n \"def get(self):\\r\\n return UserGroupService.getAllUserGroups(self)\",\n \"def groupsChanged(self):\\n # Get the list of groups for the present user according to\\n # the checklist.\\n nglist = []\\n for r in self.liststore:\\n if (r[1] and (r[0] != self.gidnm)):\\n nglist.append(r[0])\\n if (gui.getUserGroups(gui.currentUser) != nglist):\\n return nglist\\n else:\\n return None\",\n \"def path_groups(self):\\n return self._path_groups\",\n \"def get_all_groups(self, account_name=None, account_id=None, path=None, group_name=None,\\n group_id=None, search=False ):\\n grouplist=[]\\n accounts = self.get_all_accounts(account_id=account_id, account_name=account_name,\\n search=search)\\n for account in accounts:\\n groups = self.get_groups_from_account(path=path,\\n group_name=group_name,\\n group_id=group_id,\\n delegate_account=account['account_name'],\\n search=search)\\n for group in groups:\\n group['account_name']=account['account_name']\\n group['account_id']=account['account_id']\\n grouplist.append(group)\\n return grouplist\",\n \"def get_groups():\\n\\n groups = [\\\"shelter\\\", \\\"sharing\\\", \\\"unsheltered\\\", \\\"motel\\\"]\\n\\n for item in groups:\\n group = Group(group_name=item)\\n\\n db.session.add(group)\\n\\n db.session.commit()\",\n \"def get_all():\\n\\n return AGE_GROUPS\",\n \"def getGroups(self, proteinId):\\n return [self.groups[gId] for gId in self._proteinToGroupIds[proteinId]]\",\n \"def running_groups(self):\\n return set(\\n cmd.group_by for id, cmd in self.commands\\n if cmd.is_running and cmd.group_by is not None\\n )\",\n \"def get_all_groups(self, path_prefix='/', marker=None, max_items=None):\\r\\n params = {}\\r\\n if path_prefix:\\r\\n params['PathPrefix'] = path_prefix\\r\\n if marker:\\r\\n params['Marker'] = marker\\r\\n if max_items:\\r\\n params['MaxItems'] = max_items\\r\\n return self.get_response('ListGroups', params,\\r\\n list_marker='Groups')\",\n \"def group_nodes(self, group, namespace=None):\\n source = self._source(namespace)\\n return self._list(source, 'map', group)\",\n \"def getGroup(group: int, name=\\\"\\\") -> list:\\n groups = mongo.db.groups.find({'id':group},{'_id':0})\\n userID_list = []\\n user_list = []\\n for entry in groups:\\n if entry[\\\"id\\\"] == group:\\n userID_list = userID_list + entry[\\\"members\\\"]\\n if len(userID_list) != 0:\\n for entry in userID_list:\\n x = fetchUser(userId=entry)\\n user_list = user_list + x\\n return user_list\",\n \"def granted_groups(self):\\n return [\\n g\\n for g in Group.objects.filter()\\n if ManagedObject.objects.filter(GroupAccess.Q(g) & Q(id=self.id)).exists()\\n ]\",\n \"def fusion_api_get_directory_groups(self, body, api=None, headers=None):\\n return self.logindomain.groups(body, api, headers)\",\n \"def readGroups(self):\\n\\t\\tgroups = self._fileSystem.readGroups()\\n\\t\\tif groups is None:\\n\\t\\t\\treturn\\n\\t\\treturn groups\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80298066","0.7753639","0.7704329","0.76670724","0.7662189","0.7483736","0.74683553","0.7443777","0.7393224","0.7341","0.7341","0.7341","0.73013186","0.7216928","0.7213653","0.7186486","0.7179003","0.7083968","0.7080749","0.70386165","0.7009138","0.6971467","0.695359","0.6932292","0.6920581","0.6915589","0.68814","0.68720835","0.6824134","0.6812193","0.6797456","0.67920125","0.67647165","0.67603","0.67272866","0.67109436","0.6684428","0.66820747","0.66811085","0.6672757","0.66502285","0.6648071","0.66436553","0.6638446","0.66262966","0.6600514","0.6599885","0.6590717","0.659059","0.6585226","0.65730435","0.65420926","0.65278465","0.6519516","0.65170264","0.65115476","0.6507825","0.6507458","0.6505606","0.6467711","0.64584297","0.6457396","0.6457171","0.6440403","0.64367527","0.6426195","0.6390032","0.6385837","0.6376669","0.6371384","0.63549846","0.6351824","0.6346657","0.6346364","0.63414437","0.63388675","0.63154554","0.6307393","0.6306336","0.6302119","0.62926793","0.6284295","0.62838274","0.6280281","0.62772834","0.6274501","0.62701243","0.62512016","0.6248682","0.62476104","0.6238385","0.623585","0.6229484","0.62213016","0.6219128","0.6192638","0.61903054","0.6181303","0.61672324","0.6162663"],"string":"[\n \"0.80298066\",\n \"0.7753639\",\n \"0.7704329\",\n \"0.76670724\",\n \"0.7662189\",\n \"0.7483736\",\n \"0.74683553\",\n \"0.7443777\",\n \"0.7393224\",\n \"0.7341\",\n \"0.7341\",\n \"0.7341\",\n \"0.73013186\",\n \"0.7216928\",\n \"0.7213653\",\n \"0.7186486\",\n \"0.7179003\",\n \"0.7083968\",\n \"0.7080749\",\n \"0.70386165\",\n \"0.7009138\",\n \"0.6971467\",\n \"0.695359\",\n \"0.6932292\",\n \"0.6920581\",\n \"0.6915589\",\n \"0.68814\",\n \"0.68720835\",\n \"0.6824134\",\n \"0.6812193\",\n \"0.6797456\",\n \"0.67920125\",\n \"0.67647165\",\n \"0.67603\",\n \"0.67272866\",\n \"0.67109436\",\n \"0.6684428\",\n \"0.66820747\",\n \"0.66811085\",\n \"0.6672757\",\n \"0.66502285\",\n \"0.6648071\",\n \"0.66436553\",\n \"0.6638446\",\n \"0.66262966\",\n \"0.6600514\",\n \"0.6599885\",\n \"0.6590717\",\n \"0.659059\",\n \"0.6585226\",\n \"0.65730435\",\n \"0.65420926\",\n \"0.65278465\",\n \"0.6519516\",\n \"0.65170264\",\n \"0.65115476\",\n \"0.6507825\",\n \"0.6507458\",\n \"0.6505606\",\n \"0.6467711\",\n \"0.64584297\",\n \"0.6457396\",\n \"0.6457171\",\n \"0.6440403\",\n \"0.64367527\",\n \"0.6426195\",\n \"0.6390032\",\n \"0.6385837\",\n \"0.6376669\",\n \"0.6371384\",\n \"0.63549846\",\n \"0.6351824\",\n \"0.6346657\",\n \"0.6346364\",\n \"0.63414437\",\n \"0.63388675\",\n \"0.63154554\",\n \"0.6307393\",\n \"0.6306336\",\n \"0.6302119\",\n \"0.62926793\",\n \"0.6284295\",\n \"0.62838274\",\n \"0.6280281\",\n \"0.62772834\",\n \"0.6274501\",\n \"0.62701243\",\n \"0.62512016\",\n \"0.6248682\",\n \"0.62476104\",\n \"0.6238385\",\n \"0.623585\",\n \"0.6229484\",\n \"0.62213016\",\n \"0.6219128\",\n \"0.6192638\",\n \"0.61903054\",\n \"0.6181303\",\n \"0.61672324\",\n \"0.6162663\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67759746"},"document_rank":{"kind":"string","value":"32"}}},{"rowIdx":3193,"cells":{"query":{"kind":"string","value":"Get the full name of the given keyName under the current group. If extant is True, only return extant keys; otherwise return None."},"document":{"kind":"string","value":"def __getKey(self, keyNameRaw, extant=True):\n\t\tfullKeyName = self.__DELIMITER.join(\n\t\t\tself.__currentGroupNames + [str(keyNameRaw)])\n\t\tif extant and (fullKeyName not in self.__settings):\n\t\t\treturn None\n\t\treturn fullKeyName"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def key_name(self) -> Optional[str]:\n return pulumi.get(self, \"key_name\")","def get_name(self):\n return self.key().name().split(':', 1)[1]","def extract_key_name(self):\n # quick and dirty regex parsing..\n # consider using gnupg.\n _, out, _ = self.as_user('/usr/bin/gpg --list-keys')\n patterns = [\n 'pub\\s+.*?uid\\s+debrepo.*?sub\\s+\\w+/(\\w+)\\s+[\\w-]+$',\n '^pub.*?\\n\\s+(.*?)\\nuid',\n ]\n keyname = None\n out_str = out.decode('utf8')\n for pattern in patterns:\n m=re.search(pattern, out_str, flags=re.M|re.DOTALL)\n if m:\n keyname=m.group(1)\n break\n return keyname","def kms_key_name(self) -> Optional[str]:\n return pulumi.get(self, \"kms_key_name\")","def kms_key_name(self) -> Optional[str]:\n return pulumi.get(self, \"kms_key_name\")","def get_post_extra_content_key_name(obj, key_name=None):\n if obj:\n key, name = key_name.split(',')\n return obj.get_extra_content().filter(key__iexact=key, name__iexact=name)\n return ''","def key_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key_name\")","def key_name(self) -> str:\n return pulumi.get(self, \"key_name\")","def get_name(self):\n return m2.x509_extension_get_name(self.x509_ext)","def kms_key_name(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"kms_key_name\")","def kms_key_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"kms_key_name\")","def _get_key_name(self, name):\n base_path = force_text(self.location)\n final_path = urljoin(base_path + \"/\", name)\n name = os.path.normpath(final_path.lstrip('/'))\n\n if six.PY2:\n name = name.encode('utf-8')\n return name","def filename_for_key(self, key, extension=None):\n if extension is None:\n extension = self.file_extension\n f = self.key2basename(key) + extension\n return os.path.join(self.basepath, f)","def actual_key(self, key):\n key_list = []\n if key.scope == Scope.children:\n key_list.append('children')\n elif key.scope == Scope.parent:\n key_list.append('parent')\n else:\n key_list.append([\"usage\", \"definition\", \"type\", \"all\"][key.scope.block])\n\n if key.block_scope_id is not None:\n key_list.append(key.block_scope_id)\n if key.student_id:\n key_list.append(key.student_id)\n return \".\".join(key_list)","def GroupsExtension_getPackageName():\n return _libsbml.GroupsExtension_getPackageName()","def getKey(self, namespace, ns_key):\n namespace = self._fixNS(namespace)\n if namespace == BARE_NS:\n return ns_key\n\n ns_alias = self.namespaces.getAlias(namespace)\n\n # No alias is defined, so no key can exist\n if ns_alias is None:\n return None\n\n if ns_alias == NULL_NAMESPACE:\n tail = ns_key\n else:\n tail = '%s.%s' % (ns_alias, ns_key)\n\n return 'openid.' + tail","def getKeyPath(self, keyPath):\n parent = self\n parts = keyPath.split(\".\")\n for part in parts[:-1]:\n child = parent.get(part, None)\n if child is None:\n return None\n parent = child\n return parent.get(parts[-1], None)","def kms_key_name(self) -> str:\n return pulumi.get(self, \"kms_key_name\")","def kms_key_name(self) -> str:\n return pulumi.get(self, \"kms_key_name\")","def kms_key_name(self) -> str:\n return pulumi.get(self, \"kms_key_name\")","def GetKey(self, obj, keyName):\n\n key = (self._configKey is None and [\"Persistence_Options\"] or [self._configKey])[0]\n\n key += CONFIG_PATH_SEPARATOR + obj.GetKind()\n key += CONFIG_PATH_SEPARATOR + obj.GetName()\n key += CONFIG_PATH_SEPARATOR + keyName\n\n return key","def _filename(self, key):\n return os.path.join(self.root, key[:2], key)","def get_env_key(obj, key=None):\n return str.join('_', [obj.__module__.replace('.','_').upper(),\n key.upper()])","def get_key_recursive(lang_map, lang_code, key_name, default=None):\n key_val = lang_map.get(lang_code, {}).get(key_name, sentinel)\n\n if key_val is not sentinel:\n return key_val\n\n parts = lang_code.split('_')\n parts.pop()\n if not parts:\n return default\n\n _lang_code = '_'.join(parts)\n return get_key_recursive(lang_map, _lang_code, key_name, default)","def sub_key(dirname):\n return SUB_PREFIX + dirname","def key_pair_name(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"key_pair_name\")","def key_name(self):\n return self._key_name","def _key_name(self, key):\n if type(key) == type(\"\"):\n return str(curses.keyname(ord(key)).decode(\"utf-8\"))\n return False","def fname(key):\n return key.rsplit(\"/\", 1)[-1]","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def name(self):\n return self.key","def getKey(instance):\n return instance['name']","def GetSubkeyByName(self, name):","def _get_key(self, file_name, config) -> str:\n pass","def fullkey(self, key):\n if len(self.basekey) > 0:\n return \"{}:{}\".format(self.basekey, key)\n else:\n return key","def extract_key_usage(self, ext):\n res = []\n fields = KU_FIELDS[:]\n\n # \"error-on-access\", real funny\n if not ext.key_agreement:\n fields.remove('encipher_only')\n fields.remove('decipher_only')\n\n for k in fields:\n val = getattr(ext, k, False)\n if val:\n res.append(k)\n return res","def util_read_keyname(conf_file=None, verbose=0, dryrun=False):\n dr = DebRepo(dryrun=dryrun, **config(conf_file=conf_file, verbose=verbose))\n keyname = dr.read_keyname()\n print(keyname)","def get_key (self, name):\n return self + name","def get_key(self, key, default=_MISSING):\n if '.' in key:\n # Nested key of form \"foo.bar\"\n key, remainder = key.split('.', 1)\n if default != _MISSING:\n try:\n value = self[key].get_key(remainder, default)\n except KeyError:\n # subdict exists, but doesn't contain key\n return default\n except AttributeError:\n # key points to non-dict thing, so no get_key attribute\n return default\n else:\n value = self[key].get_key(remainder)\n else:\n # Single, non-nested key of form \"foo\"\n if default != _MISSING:\n return self.get(key, default)\n else:\n return self[key]\n return value","def get_root_key(name):\n return \"REZ_{name}_ROOT\".format(name=name.upper())","def get_key_and_internalname(self, public_id):\n query = \"\"\"SELECT aeskey,\n internalname\n FROM yubikeys\n WHERE (active = '1' OR active = 'true')\n AND publicname = %s\"\"\"\n self._execute(query, (public_id,))\n return self._dictfetchone()","def getName(self):\n return _libsbml.GroupsExtension_getName(self)","def key_object_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key_object_name\")","def key_pair_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key_pair_name\")","def key_pair_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key_pair_name\")","def key_pair_name(self) -> str:\n return pulumi.get(self, \"key_pair_name\")","def get_full_name(self):\n return \"{vol} ({fs})\".format(vol=self.volume_id, fs=self.fs.get_full_name())","def get_name_activated_plugin(self, key):\n plugins = self.get_all_childname(key)\n for plugin in plugins:\n if self.get(key, plugin, format=bool):\n return plugin\n return None","def build_flattened_key(prefix, key):\n return key if not prefix else prefix + \".\" + key","def _get_raw_key(args, key_field_name):\n flag_key = getattr(args, key_field_name, None)\n if flag_key is not None:\n return flag_key\n return _read_key_store_file().get(key_field_name)","def root_given_key(prob_key):\n root = ''\n for i, info in enumerate(prob_key):\n if i != 0:\n root += '_'\n root += str(info)\n return root.replace('.', '_')","def getKey( self, key ):\n if key in self.conf:\n return self.conf[key]\n else:\n return None","def get_key(self, language_name, key):\n self.language_name_global = language_name\n self.key_global = key\n package_path = f\"language_manager/packages/{language_name}.langpkg\"\n if not self.__copy_check_same__(package_path):\n self.__copy__(package_path)\n\n # Import the temp Python file coming out of the package\n import temp\n self.__log__(f\"Getting key \\\"{key}\\\"\\n\")\n # Take the key (type: str)\n return_val = temp.LANGUAGE[\"contents\"][key]\n self.__log__(\"Done.\")\n # Delete the language package from the RAM to free up space\n del temp\n self.__log__(\"\\n--- Finished function call ---\\n\\n\")\n # Return the value of the key\n return return_val","def get_store_key(asset):\n return '.'.join([asset.name, asset.uid, asset.ext])","def _format_key(self, k: str) -> str:\n if k[0] == '.':\n k = k[1:]\n k = k.replace('.', '_')\n k = k.upper()\n k = re.sub(self.KEY_REGEX, '', k)\n return k","def key_from_req(req):\n if hasattr(req, \"key\"):\n # from pkg_resources, such as installed dists for pip-sync\n key = req.key\n else:\n # from packaging, such as install requirements from requirements.txt\n key = req.name\n\n key = key.replace(\"_\", \"-\").lower()\n return key","def shorter_name(key):\n key_short = key\n for sep in ['#', '/']:\n ind = key_short.rfind(sep)\n if ind is not None:\n key_short = key_short[ind+1:]\n else:\n key_short = key_short\n return key_short.replace('-', '_').replace('.', '_')","def key(self):\n return key_for_name(self.name)","def get_ext(f_name):\n \n for i in range(len(f_name)-1,-1,-1):\n if f_name[i]=='.':\n return f_name[i:]\n return None","def get_all_childname(self, key):\n return [x.split(\"/\")[1] for x in self.get_all_keys() if x.split(\"/\")[0] == key]","def generate_key(self):\n cmd = self.generate_key_cmd()\n self.show(cmd)\n if self.dryrun:\n return None\n s, _, _ = self.as_user(cmd)\n assert s == 0, ('failed to generate key', cmd)\n keyname = self.extract_key_name()\n return keyname","def _get_key_path(self, key_name, serial):\n return '%s%s/%d_%s.key' % (self.ca_dir, PRIVATE_DIR_NAME, serial,\n key_name)","def _get_deployment_friendly_name(auth_header, async_kvstore_client, request_context):\n\n response = yield async_kvstore_client.async_kvstore_get_request(\n constants.META_COLLECTION_NAME, auth_header=auth_header, owner=constants.NOBODY)\n\n if response.code == http.OK:\n response_json = yield response.json()\n defer.returnValue(response_json[0][constants.DEPLOYMENT_FRIENDLY_NAME])\n\n LOGGER.error(\"Unable to fetch deployment friendly name for instance, code={}\".format(response.code))\n defer.returnValue(\"\")","def _getKEX(group, version):\n if group in GroupName.allFF:\n return FFDHKeyExchange(group, version)\n return ECDHKeyExchange(group, version)","def read_keyname(self):\n self.show(f'cat {self.keyname_file}')\n with open(self.keyname_file) as f:\n keyname = f.readline().strip()\n self.report('Using key:', keyname)\n return keyname","def get_store_key(asset, variation):\n return '.'.join([\n asset.name,\n asset.uid,\n variation.name,\n variation.version,\n variation.ext\n ])","def get_filename(self):\n name, ext = self.fkit.filename.rsplit('.', 1)\n if self._field.extension():\n ext = self._field.extension()\n return '.'.join((name, ext))","def get_item_key(self, filename):\n _instrument, filekind = utils.get_file_properties(self.observatory, filename)\n return filekind.upper() if self.observatory == \"jwst\" else filekind.lower()","def subkey(cls, key: str, start: int, end: Optional[int]) -> Optional[str]:\n key_parts = key.split(\".\")\n\n # if end not specified set to max.\n if end is None:\n end = len(key_parts)\n\n if len(key_parts) < start or len(key_parts) < end:\n return None\n\n res = \".\".join(key_parts[start:end])\n return res","def get_key(self, key):\n ret = None\n qkey = key.__qualname__\n ret = self.get(qkey)\n if not ret:\n # check all entries if qualname match\n for k in self:\n if k.__qualname__ == qkey:\n return self.get(k)\n return","def cache_key_part(self) -> str:\n return self.name","def get_name_for_actor(actor, keyName=\"MeshName\"):\n information = actor.GetPropertyKeys()\n if information is None:\n return None\n\n iterator = vtkInformationIterator()\n iterator.SetInformation(information)\n iterator.InitTraversal()\n while (not iterator.IsDoneWithTraversal()):\n key = iterator.GetCurrentKey()\n if key.GetName() == keyName:\n return information.Get(key)\n break\n iterator.GoToNextItem()\n return None","def extension_name(ext):\n return \"script_extensions::%s\" % \"_\".join([e.upper() for e in ext])"],"string":"[\n \"def key_name(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key_name\\\")\",\n \"def get_name(self):\\n return self.key().name().split(':', 1)[1]\",\n \"def extract_key_name(self):\\n # quick and dirty regex parsing..\\n # consider using gnupg.\\n _, out, _ = self.as_user('/usr/bin/gpg --list-keys')\\n patterns = [\\n 'pub\\\\s+.*?uid\\\\s+debrepo.*?sub\\\\s+\\\\w+/(\\\\w+)\\\\s+[\\\\w-]+$',\\n '^pub.*?\\\\n\\\\s+(.*?)\\\\nuid',\\n ]\\n keyname = None\\n out_str = out.decode('utf8')\\n for pattern in patterns:\\n m=re.search(pattern, out_str, flags=re.M|re.DOTALL)\\n if m:\\n keyname=m.group(1)\\n break\\n return keyname\",\n \"def kms_key_name(self) -> Optional[str]:\\n return pulumi.get(self, \\\"kms_key_name\\\")\",\n \"def kms_key_name(self) -> Optional[str]:\\n return pulumi.get(self, \\\"kms_key_name\\\")\",\n \"def get_post_extra_content_key_name(obj, key_name=None):\\n if obj:\\n key, name = key_name.split(',')\\n return obj.get_extra_content().filter(key__iexact=key, name__iexact=name)\\n return ''\",\n \"def key_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key_name\\\")\",\n \"def key_name(self) -> str:\\n return pulumi.get(self, \\\"key_name\\\")\",\n \"def get_name(self):\\n return m2.x509_extension_get_name(self.x509_ext)\",\n \"def kms_key_name(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"kms_key_name\\\")\",\n \"def kms_key_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"kms_key_name\\\")\",\n \"def _get_key_name(self, name):\\n base_path = force_text(self.location)\\n final_path = urljoin(base_path + \\\"/\\\", name)\\n name = os.path.normpath(final_path.lstrip('/'))\\n\\n if six.PY2:\\n name = name.encode('utf-8')\\n return name\",\n \"def filename_for_key(self, key, extension=None):\\n if extension is None:\\n extension = self.file_extension\\n f = self.key2basename(key) + extension\\n return os.path.join(self.basepath, f)\",\n \"def actual_key(self, key):\\n key_list = []\\n if key.scope == Scope.children:\\n key_list.append('children')\\n elif key.scope == Scope.parent:\\n key_list.append('parent')\\n else:\\n key_list.append([\\\"usage\\\", \\\"definition\\\", \\\"type\\\", \\\"all\\\"][key.scope.block])\\n\\n if key.block_scope_id is not None:\\n key_list.append(key.block_scope_id)\\n if key.student_id:\\n key_list.append(key.student_id)\\n return \\\".\\\".join(key_list)\",\n \"def GroupsExtension_getPackageName():\\n return _libsbml.GroupsExtension_getPackageName()\",\n \"def getKey(self, namespace, ns_key):\\n namespace = self._fixNS(namespace)\\n if namespace == BARE_NS:\\n return ns_key\\n\\n ns_alias = self.namespaces.getAlias(namespace)\\n\\n # No alias is defined, so no key can exist\\n if ns_alias is None:\\n return None\\n\\n if ns_alias == NULL_NAMESPACE:\\n tail = ns_key\\n else:\\n tail = '%s.%s' % (ns_alias, ns_key)\\n\\n return 'openid.' + tail\",\n \"def getKeyPath(self, keyPath):\\n parent = self\\n parts = keyPath.split(\\\".\\\")\\n for part in parts[:-1]:\\n child = parent.get(part, None)\\n if child is None:\\n return None\\n parent = child\\n return parent.get(parts[-1], None)\",\n \"def kms_key_name(self) -> str:\\n return pulumi.get(self, \\\"kms_key_name\\\")\",\n \"def kms_key_name(self) -> str:\\n return pulumi.get(self, \\\"kms_key_name\\\")\",\n \"def kms_key_name(self) -> str:\\n return pulumi.get(self, \\\"kms_key_name\\\")\",\n \"def GetKey(self, obj, keyName):\\n\\n key = (self._configKey is None and [\\\"Persistence_Options\\\"] or [self._configKey])[0]\\n\\n key += CONFIG_PATH_SEPARATOR + obj.GetKind()\\n key += CONFIG_PATH_SEPARATOR + obj.GetName()\\n key += CONFIG_PATH_SEPARATOR + keyName\\n\\n return key\",\n \"def _filename(self, key):\\n return os.path.join(self.root, key[:2], key)\",\n \"def get_env_key(obj, key=None):\\n return str.join('_', [obj.__module__.replace('.','_').upper(),\\n key.upper()])\",\n \"def get_key_recursive(lang_map, lang_code, key_name, default=None):\\n key_val = lang_map.get(lang_code, {}).get(key_name, sentinel)\\n\\n if key_val is not sentinel:\\n return key_val\\n\\n parts = lang_code.split('_')\\n parts.pop()\\n if not parts:\\n return default\\n\\n _lang_code = '_'.join(parts)\\n return get_key_recursive(lang_map, _lang_code, key_name, default)\",\n \"def sub_key(dirname):\\n return SUB_PREFIX + dirname\",\n \"def key_pair_name(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"key_pair_name\\\")\",\n \"def key_name(self):\\n return self._key_name\",\n \"def _key_name(self, key):\\n if type(key) == type(\\\"\\\"):\\n return str(curses.keyname(ord(key)).decode(\\\"utf-8\\\"))\\n return False\",\n \"def fname(key):\\n return key.rsplit(\\\"/\\\", 1)[-1]\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def name(self):\\n return self.key\",\n \"def getKey(instance):\\n return instance['name']\",\n \"def GetSubkeyByName(self, name):\",\n \"def _get_key(self, file_name, config) -> str:\\n pass\",\n \"def fullkey(self, key):\\n if len(self.basekey) > 0:\\n return \\\"{}:{}\\\".format(self.basekey, key)\\n else:\\n return key\",\n \"def extract_key_usage(self, ext):\\n res = []\\n fields = KU_FIELDS[:]\\n\\n # \\\"error-on-access\\\", real funny\\n if not ext.key_agreement:\\n fields.remove('encipher_only')\\n fields.remove('decipher_only')\\n\\n for k in fields:\\n val = getattr(ext, k, False)\\n if val:\\n res.append(k)\\n return res\",\n \"def util_read_keyname(conf_file=None, verbose=0, dryrun=False):\\n dr = DebRepo(dryrun=dryrun, **config(conf_file=conf_file, verbose=verbose))\\n keyname = dr.read_keyname()\\n print(keyname)\",\n \"def get_key (self, name):\\n return self + name\",\n \"def get_key(self, key, default=_MISSING):\\n if '.' in key:\\n # Nested key of form \\\"foo.bar\\\"\\n key, remainder = key.split('.', 1)\\n if default != _MISSING:\\n try:\\n value = self[key].get_key(remainder, default)\\n except KeyError:\\n # subdict exists, but doesn't contain key\\n return default\\n except AttributeError:\\n # key points to non-dict thing, so no get_key attribute\\n return default\\n else:\\n value = self[key].get_key(remainder)\\n else:\\n # Single, non-nested key of form \\\"foo\\\"\\n if default != _MISSING:\\n return self.get(key, default)\\n else:\\n return self[key]\\n return value\",\n \"def get_root_key(name):\\n return \\\"REZ_{name}_ROOT\\\".format(name=name.upper())\",\n \"def get_key_and_internalname(self, public_id):\\n query = \\\"\\\"\\\"SELECT aeskey,\\n internalname\\n FROM yubikeys\\n WHERE (active = '1' OR active = 'true')\\n AND publicname = %s\\\"\\\"\\\"\\n self._execute(query, (public_id,))\\n return self._dictfetchone()\",\n \"def getName(self):\\n return _libsbml.GroupsExtension_getName(self)\",\n \"def key_object_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key_object_name\\\")\",\n \"def key_pair_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key_pair_name\\\")\",\n \"def key_pair_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key_pair_name\\\")\",\n \"def key_pair_name(self) -> str:\\n return pulumi.get(self, \\\"key_pair_name\\\")\",\n \"def get_full_name(self):\\n return \\\"{vol} ({fs})\\\".format(vol=self.volume_id, fs=self.fs.get_full_name())\",\n \"def get_name_activated_plugin(self, key):\\n plugins = self.get_all_childname(key)\\n for plugin in plugins:\\n if self.get(key, plugin, format=bool):\\n return plugin\\n return None\",\n \"def build_flattened_key(prefix, key):\\n return key if not prefix else prefix + \\\".\\\" + key\",\n \"def _get_raw_key(args, key_field_name):\\n flag_key = getattr(args, key_field_name, None)\\n if flag_key is not None:\\n return flag_key\\n return _read_key_store_file().get(key_field_name)\",\n \"def root_given_key(prob_key):\\n root = ''\\n for i, info in enumerate(prob_key):\\n if i != 0:\\n root += '_'\\n root += str(info)\\n return root.replace('.', '_')\",\n \"def getKey( self, key ):\\n if key in self.conf:\\n return self.conf[key]\\n else:\\n return None\",\n \"def get_key(self, language_name, key):\\n self.language_name_global = language_name\\n self.key_global = key\\n package_path = f\\\"language_manager/packages/{language_name}.langpkg\\\"\\n if not self.__copy_check_same__(package_path):\\n self.__copy__(package_path)\\n\\n # Import the temp Python file coming out of the package\\n import temp\\n self.__log__(f\\\"Getting key \\\\\\\"{key}\\\\\\\"\\\\n\\\")\\n # Take the key (type: str)\\n return_val = temp.LANGUAGE[\\\"contents\\\"][key]\\n self.__log__(\\\"Done.\\\")\\n # Delete the language package from the RAM to free up space\\n del temp\\n self.__log__(\\\"\\\\n--- Finished function call ---\\\\n\\\\n\\\")\\n # Return the value of the key\\n return return_val\",\n \"def get_store_key(asset):\\n return '.'.join([asset.name, asset.uid, asset.ext])\",\n \"def _format_key(self, k: str) -> str:\\n if k[0] == '.':\\n k = k[1:]\\n k = k.replace('.', '_')\\n k = k.upper()\\n k = re.sub(self.KEY_REGEX, '', k)\\n return k\",\n \"def key_from_req(req):\\n if hasattr(req, \\\"key\\\"):\\n # from pkg_resources, such as installed dists for pip-sync\\n key = req.key\\n else:\\n # from packaging, such as install requirements from requirements.txt\\n key = req.name\\n\\n key = key.replace(\\\"_\\\", \\\"-\\\").lower()\\n return key\",\n \"def shorter_name(key):\\n key_short = key\\n for sep in ['#', '/']:\\n ind = key_short.rfind(sep)\\n if ind is not None:\\n key_short = key_short[ind+1:]\\n else:\\n key_short = key_short\\n return key_short.replace('-', '_').replace('.', '_')\",\n \"def key(self):\\n return key_for_name(self.name)\",\n \"def get_ext(f_name):\\n \\n for i in range(len(f_name)-1,-1,-1):\\n if f_name[i]=='.':\\n return f_name[i:]\\n return None\",\n \"def get_all_childname(self, key):\\n return [x.split(\\\"/\\\")[1] for x in self.get_all_keys() if x.split(\\\"/\\\")[0] == key]\",\n \"def generate_key(self):\\n cmd = self.generate_key_cmd()\\n self.show(cmd)\\n if self.dryrun:\\n return None\\n s, _, _ = self.as_user(cmd)\\n assert s == 0, ('failed to generate key', cmd)\\n keyname = self.extract_key_name()\\n return keyname\",\n \"def _get_key_path(self, key_name, serial):\\n return '%s%s/%d_%s.key' % (self.ca_dir, PRIVATE_DIR_NAME, serial,\\n key_name)\",\n \"def _get_deployment_friendly_name(auth_header, async_kvstore_client, request_context):\\n\\n response = yield async_kvstore_client.async_kvstore_get_request(\\n constants.META_COLLECTION_NAME, auth_header=auth_header, owner=constants.NOBODY)\\n\\n if response.code == http.OK:\\n response_json = yield response.json()\\n defer.returnValue(response_json[0][constants.DEPLOYMENT_FRIENDLY_NAME])\\n\\n LOGGER.error(\\\"Unable to fetch deployment friendly name for instance, code={}\\\".format(response.code))\\n defer.returnValue(\\\"\\\")\",\n \"def _getKEX(group, version):\\n if group in GroupName.allFF:\\n return FFDHKeyExchange(group, version)\\n return ECDHKeyExchange(group, version)\",\n \"def read_keyname(self):\\n self.show(f'cat {self.keyname_file}')\\n with open(self.keyname_file) as f:\\n keyname = f.readline().strip()\\n self.report('Using key:', keyname)\\n return keyname\",\n \"def get_store_key(asset, variation):\\n return '.'.join([\\n asset.name,\\n asset.uid,\\n variation.name,\\n variation.version,\\n variation.ext\\n ])\",\n \"def get_filename(self):\\n name, ext = self.fkit.filename.rsplit('.', 1)\\n if self._field.extension():\\n ext = self._field.extension()\\n return '.'.join((name, ext))\",\n \"def get_item_key(self, filename):\\n _instrument, filekind = utils.get_file_properties(self.observatory, filename)\\n return filekind.upper() if self.observatory == \\\"jwst\\\" else filekind.lower()\",\n \"def subkey(cls, key: str, start: int, end: Optional[int]) -> Optional[str]:\\n key_parts = key.split(\\\".\\\")\\n\\n # if end not specified set to max.\\n if end is None:\\n end = len(key_parts)\\n\\n if len(key_parts) < start or len(key_parts) < end:\\n return None\\n\\n res = \\\".\\\".join(key_parts[start:end])\\n return res\",\n \"def get_key(self, key):\\n ret = None\\n qkey = key.__qualname__\\n ret = self.get(qkey)\\n if not ret:\\n # check all entries if qualname match\\n for k in self:\\n if k.__qualname__ == qkey:\\n return self.get(k)\\n return\",\n \"def cache_key_part(self) -> str:\\n return self.name\",\n \"def get_name_for_actor(actor, keyName=\\\"MeshName\\\"):\\n information = actor.GetPropertyKeys()\\n if information is None:\\n return None\\n\\n iterator = vtkInformationIterator()\\n iterator.SetInformation(information)\\n iterator.InitTraversal()\\n while (not iterator.IsDoneWithTraversal()):\\n key = iterator.GetCurrentKey()\\n if key.GetName() == keyName:\\n return information.Get(key)\\n break\\n iterator.GoToNextItem()\\n return None\",\n \"def extension_name(ext):\\n return \\\"script_extensions::%s\\\" % \\\"_\\\".join([e.upper() for e in ext])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61867285","0.6151179","0.59994215","0.59087443","0.59087443","0.58050305","0.57887447","0.57743907","0.57119745","0.5711618","0.56672543","0.5649241","0.5592001","0.55778885","0.55366206","0.55205065","0.55190045","0.55060714","0.55060714","0.55060714","0.54835165","0.5469332","0.5467664","0.546364","0.54382837","0.53961414","0.5376713","0.5361389","0.5351113","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5327895","0.5325407","0.53189397","0.52868634","0.5285683","0.5267129","0.52354467","0.5235304","0.523","0.5225603","0.52222806","0.5219983","0.52100414","0.5196049","0.51808256","0.51808256","0.5179719","0.5178627","0.51777536","0.51777405","0.51681334","0.5167156","0.5164629","0.51409614","0.5135669","0.5127195","0.5121901","0.51085705","0.5102542","0.51005733","0.5090503","0.50850207","0.5073992","0.5059809","0.50549346","0.5050695","0.5039707","0.50334877","0.5031385","0.50285214","0.50285155","0.5025204","0.50206715","0.5013364"],"string":"[\n \"0.61867285\",\n \"0.6151179\",\n \"0.59994215\",\n \"0.59087443\",\n \"0.59087443\",\n \"0.58050305\",\n \"0.57887447\",\n \"0.57743907\",\n \"0.57119745\",\n \"0.5711618\",\n \"0.56672543\",\n \"0.5649241\",\n \"0.5592001\",\n \"0.55778885\",\n \"0.55366206\",\n \"0.55205065\",\n \"0.55190045\",\n \"0.55060714\",\n \"0.55060714\",\n \"0.55060714\",\n \"0.54835165\",\n \"0.5469332\",\n \"0.5467664\",\n \"0.546364\",\n \"0.54382837\",\n \"0.53961414\",\n \"0.5376713\",\n \"0.5361389\",\n \"0.5351113\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5327895\",\n \"0.5325407\",\n \"0.53189397\",\n \"0.52868634\",\n \"0.5285683\",\n \"0.5267129\",\n \"0.52354467\",\n \"0.5235304\",\n \"0.523\",\n \"0.5225603\",\n \"0.52222806\",\n \"0.5219983\",\n \"0.52100414\",\n \"0.5196049\",\n \"0.51808256\",\n \"0.51808256\",\n \"0.5179719\",\n \"0.5178627\",\n \"0.51777536\",\n \"0.51777405\",\n \"0.51681334\",\n \"0.5167156\",\n \"0.5164629\",\n \"0.51409614\",\n \"0.5135669\",\n \"0.5127195\",\n \"0.5121901\",\n \"0.51085705\",\n \"0.5102542\",\n \"0.51005733\",\n \"0.5090503\",\n \"0.50850207\",\n \"0.5073992\",\n \"0.5059809\",\n \"0.50549346\",\n \"0.5050695\",\n \"0.5039707\",\n \"0.50334877\",\n \"0.5031385\",\n \"0.50285214\",\n \"0.50285155\",\n \"0.5025204\",\n \"0.50206715\",\n \"0.5013364\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77827585"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3194,"cells":{"query":{"kind":"string","value":"This function gets the total occurrences of words and syllables in the original Unicode Garshana corpus. To do this, it opens a .csv file with utf16 encoding, and splits on commans, expecting the line of sumerian text to be in the 8th column. Filters annotations from each line, and tracks the occurrence of each word and syllable. All combinations of unigrams, bigrams, and trigrams are treated as individual syllables."},"document":{"kind":"string","value":"def get_counts(data):\n\n word_count = {}\n syll_count = {}\n\n infile = data.corpus\n try:\n\n open_file = codecs.open(infile, 'r', encoding='utf-16')\n for line in open_file:\n line = line.lower()\n # Remove tablet indexing info and line numbers. Grab only text data\n line = line.split(',')\n text = clean_line(line[7])\n\n # Update the occurrences of the words in the line\n for word in text.split():\n count = word_count.setdefault(word, 0)\n word_count[word] = count + 1\n\n # Track occurrences of syllables\n update_syllable_count(word, syll_count)\n\n open_file.close()\n except IOError:\n print(\"Cannot open: \" + infile)\n\n return (word_count, syll_count)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load_word_counts(filename):\n raw_rows = csv_rows(filename)\n word_counts = defaultdict(lambda: 0)\n\n for line_number, raw_row in enumerate(raw_rows, 2):\n count = int(raw_row[\"count\"])\n ipa = raw_row[\"IPA\"]\n if '*' in ipa:\n continue\n\n # Fixes random badness.. hopefully doesn't hide anything?\n mod_ipa = ipa.replace('(', '').replace(')', '')\n\n # Work around a passage with an error in it:\n gloss = raw_row[\"Gloss\"] or raw_row[\"Text\"]\n\n category = raw_row[\"Category\"]\n\n skipword_characters = {'?'}\n try:\n for i, g in izip(mod_ipa.split('/'), gloss.split('/')):\n word = make_word(i, g, category)\n word_counts[word] += count\n except WordParseError as e:\n print (u\"Error on line %d: %s [%s || %s]\" %\n (line_number, repr(e), ipa, gloss)).encode('utf-8')\n except IndexError as e:\n unknown_index = e.args[0]\n if unknown_index in skipword_characters:\n print (u\"Bad char on line %d: %s [%s || %s]\" %\n (line_number, repr(e), ipa, gloss)).encode('utf-8')\n else:\n print \"FATAL ERROR ON LINE %d\" % line_number\n raise\n except:\n print \"FATAL ERROR ON LINE %d\" % line_number\n raise\n return word_counts","def total_syllables(target_text):\n\n splited_text = target_text.split()\n count = 0\n for word in splited_text:\n count = count + word_syllables(word)\n return count","def get_analyze_per_file(self):\n \"\"\"Exclude tags, exclude binary (img), count words without non literal characters and digits\"\"\"\n filename = f'{self.path}/{self.filename}'\n file = open(filename, 'r', encoding='utf-8')\n df_tmp = pd.DataFrame(columns=['word', 'cnt', 'word_low'])\n w_cnt = 0\n word_counter = {}\n data = file.read()\n head, sep, tail = data.partition('<binary')\n head = re.sub('\\\\s\\\\s*', ' ', (re.sub('\\\\W|\\\\d', ' ', re.sub('<.*?>', '', head))))\n word_list = head.split()\n for word in word_list:\n\n if word not in word_counter:\n word_counter[word] = 1\n else:\n word_counter[word] = word_counter[word] + 1\n w_cnt += 1\n\n for word, occurance in word_counter.items():\n df_tmp = df_tmp.append({'word': '{:15}'.format(word), 'cnt': '{:3}'.format(occurance),\n 'word_low': '{:15}'.format(word).lower()}, ignore_index=True)\n df_tmp = df_tmp.sort_values(by='word_low')\n df_tmp.loc[(df_tmp.word != df_tmp.word_low), 'word'] = df_tmp.cnt\n df_tmp.loc[(df_tmp.word == df_tmp.cnt), 'cnt'] = 0\n df_tmp.loc[(df_tmp.word == df_tmp.word_low), 'word'] = 0\n df_tmp['word'] = df_tmp.word.astype(int)\n df_tmp['cnt'] = df_tmp.cnt.astype(int)\n df_tmp = df_tmp.groupby(['word_low'])['cnt', 'word'].sum().reset_index()\n conn = sqlite3.connect('for_python_ht.db')\n try:\n try:\n sqlite_for_ht.CreateTableSingle.delete_table(f_3, self.filename)\n print(datetime.now(), '-', self.filename, 'Table deleted at the start point')\n except Exception:\n print(datetime.now(), '-', 'Something went wrong')\n traceback.print_exc()\n df_tmp.to_sql(name=self.filename, con=conn, index=False)\n print(datetime.now(), '-', self.filename, 'Table created and filled with data')\n except Exception:\n print(datetime.now(), '-', 'file with name {} already exists'.format(self.filename))\n traceback.print_exc()\n print(datetime.now(), '-', 'word analyse for', self.filename, 'done')\n sqlite_for_ht.HandleTemp.update_table(f_2, 'status', 'Done', self.filename)\n return None","def process():\n words = read_csv('american-words.80', header=None)\n def get_value(word):\n \"\"\"\n A sub-process run on each word. It gets the value of each letter, and add up the values for the whole word.\n \"\"\"\n letters = 'abcdefghijklmnopqrstuvwxyz'\n sum = 0\n for letter in word:\n letter_value = letters.find(letter)\n if letter_value == -1:\n letter_value = 0\n sum += letter_value\n return sum\n words['values'] = words[0].apply(get_value)\n # get those words whose values are 100\n words = words[words['values'] == 100]\n # get the length of these words and sort ascending\n words['length'] = words[0].apply(len)\n words = words.sort(columns='length')\n return words[0].values","def analyze_data(df, sentiment_col, tweet_col, path):\n\n # create empty dictionaries to store all encountered words and their frequencies\n all_dict = {}\n pos_dict = {}\n neg_dict = {}\n neu_dict = {}\n # initialize counters to counter total number of tweets based on their emotion\n pos_count = 0\n neg_count = 0\n neu_count = 0\n\n # iterate through each row of the df\n for index, row in df.iterrows():\n if row[sentiment_col] == \"positive\":\n pos_count = iterate_words(\n pos_count, row[tweet_col], all_dict, pos_dict)\n\n if row[sentiment_col] == \"negative\":\n neg_count = iterate_words(\n neg_count, row[tweet_col], all_dict, neg_dict)\n\n if row[sentiment_col] == \"neutral\":\n neu_count = iterate_words(\n neu_count, row[tweet_col], all_dict, neu_dict)\n\n # visualize statistics\n visualize_stats(all_dict, 'all_plot.png', 'all_cloud.png',\n 'Word frequency in all tweets', path)\n visualize_stats(pos_dict, 'pos_plot.png', 'pos_cloud.png',\n 'Word frequency in positive tweets', path)\n visualize_stats(neg_dict, 'neg_plot.png', 'neg_cloud.png',\n 'Word frequency in negative tweets', path)\n visualize_stats(neu_dict, 'neu_plot.png', 'neu_cloud.png',\n 'Word frequency in neutral tweets', path)\n\n # make plot for emotion frequency\n emotions = ('Positive', 'Negative', 'Neutral')\n freq = [pos_count, neg_count, neu_count]\n sns.set_style(\"darkgrid\")\n ax = plt.figure().gca()\n ax.xaxis.grid(False)\n ax.yaxis.set_major_locator(MaxNLocator(integer=True))\n plt.bar(range(len(emotions)), freq, align='center',\n color=['forestgreen', 'firebrick', 'goldenrod'])\n plt.xticks(range(len(emotions)), emotions)\n plt.title('Tweet frequency based on emotion')\n plt.savefig(path + 'emotion_plot.png')\n plt.close()\n\n # make pie for emotion frequency\n sizes = [pos_count / len(df.index), neg_count /\n len(df.index), neu_count / len(df.index)]\n colors = ['forestgreen', 'firebrick', 'goldenrod']\n plt.pie(sizes, labels=emotions, colors=colors,\n autopct='%1.1f%%', startangle=140)\n plt.title('Tweet frequency based on emotion')\n plt.axis('equal')\n plt.savefig(path + 'emotion_pie.png')\n plt.close()","def main ():\n fio = FileIo(\"../input2.txt\")\n text = fio.getInput()\n p = re.compile(r'#?\\d[\\s\\.]?[\\s]?')\n out = filter(None, p.split(text))\n #print out[2]\n #print len(out)\n wc = 0\n\n for s in out:\n text = nltk.word_tokenize(s)\n wc += wordCount( text )\n print wc","def extract_syllable_features_from_txt():\n input_files = sys.argv[1]\n csv_name = sys.argv[2]\n syllable_stats = pd.DataFrame(columns=SYLLABLE_COLUMNS)\n re_word = re.compile(r'[\\w-]+')\n i = 0\n for filename in os.listdir(input_files):\n if filename != '.DS_Store':\n print(filename, i)\n syllable_count = 0\n for line in open(input_files+filename):\n for word in re_word.findall(line):\n syllable_count += estimate(word)\n syllable_stats = syllable_stats.append({\n TRANSCRIPT_ID: filename[:-4],\n MEMORY_SYLLABLE_COUNT: syllable_count,\n }, ignore_index=True)\n i += 1\n syllable_stats = syllable_stats.set_index(TRANSCRIPT_ID)\n syllable_stats.to_csv(csv_name+'.csv')","def count_words(filename):","def analyze_embeddings(emb):\n dic = {\"Hi\": 0, \"En\": 1, \"Ot\": 2}\n count = [0, 0, 0, 0]\n count_zero = [0, 0, 0, 0]\n for i, j in zip(emb, corpus_trans):\n for k, l in zip(i, j):\n count[dic[l[1]]] += 1\n if sum(k) == 0:\n count_zero[dic[l[1]]] += 1\n count[-1] = sum(count)\n count_zero[-1] - sum(count_zero)\n print(\"hi, en, ot, total\")\n print(\"count: \", count)\n print(\"zero count: \", count_zero)","def updateWordCounts():\n emaildata = loadEmailData()\n englishwords = importDictionary()\n countAllWords(emaildata, englishwords)","def summarize_corpus():\n\t\n\t# get metadata\n\t#get_metadata.from_TEIP5(wdir, corpus_inpath, \"metadata\", md_mode)\n\t\n\t# visualize some metadata\n\t#visualize_metadata.describe_corpus(wdir, md_csv, \"author-continent\")\n\tvisualize_metadata.describe_corpus(wdir, md_csv, \"author-country\")\n\t#visualize_metadata.describe_corpus(wdir, md_csv, \"language\")\n\t#visualize_metadata.describe_corpus(wdir, md_csv, \"subgenre_hist\")\n\t#visualize_metadata.describe_corpus(wdir, md_csv, \"subgenre_x\")\n\tvisualize_metadata.plot_pie(wdir, md_csv, \"subgenre\")\n\n\tvisualize_metadata.describe_corpus(wdir, md_csv, \"subgenre\")\n\t#visualize_metadata.describe_corpus(wdir, md_csv, \"gender\")\n\t\n\t# make some counts\n\tmd_table = pd.DataFrame.from_csv(os.path.join(wdir, md_csv), header=0)\n\tnum_texts = len(md_table)\n\t#num_language = len(md_table.groupby([\"language\"]))\n\t#num_continent = len(md_table.groupby([\"author-continent\"]))\n\t#num_countries = len(md_table.groupby([\"author-country\"]))\n\t#num_authors = len(md_table.groupby([\"author-name\"]))\n\tnum_authors = len(md_table.groupby([\"author-name\"]))\n\tnum_subgenre = len(md_table.groupby([\"subgenre\"]))\n\t#num_subgenre_x = len(md_table.groupby([\"subgenre_x\"]))\n\t#fr_subgenre_hist = md_table.groupby([\"subgenre_hist\"]).count()\n\t#num_historical = fr_subgenre_hist[\"idno\"][\"historical\"]\n\t#num_not_historical = fr_subgenre_hist[\"idno\"][\"not_historical\"]\n\t\n\t\n\td = {\"texts\":[num_texts], \n\t#\"languages\":[num_language],\n\t#\"continents\":[num_continent],\n\t#\"countries\":[num_countries],\n\t\"authors\":[num_authors],\n\t#\"subgenre_x\":[num_subgenre_x],\n\t\"subgenre\":[num_subgenre]}\n\t#\"num_historical\":[num_historical],\n\t#\"num_not_historical\":[num_not_historical]}\n\t\n\t\n\t\n\tcount_fr = pd.DataFrame(d)\n\tcount_fr.to_csv(os.path.join(wdir, \"corpus-description.csv\"), sep=\",\", header=True)\n\tprint(\"Done: summarize corpus\")","def _count_vocab(self,raw_documents, fixed_vocab=False):\n if fixed_vocab:\n vocabulary = self.vocabulary_\n else:\n # Add a new value when a new vocabulary item is seen\n vocabulary = defaultdict()\n vocabulary.default_factory = vocabulary.__len__\n\n analyze = super().build_analyzer()\n \n j_indices = []\n indptr = []\n\n values = array.array(str('f'))\n indptr.append(0)\n for doc in raw_documents:\n #doc = tupla[0]\n feature_counter = {}\n #texttlist = doc.split(sep=\" \")\n for feature in analyze(doc):#texttlist:\n try:\n \n # Ignore out-of-vocabulary items for fixed_vocab=True\n feature_idx = vocabulary[feature]\n #print(feature_idx)\n #fti_feature = calc_fti(feature,raw_documents)\n \n if feature_idx not in feature_counter:\n feature_counter[feature_idx] = 1\n else:\n feature_counter[feature_idx] += 1\n #print(feature_counter[feature_idx])\n except KeyError:\n # Ignore out-of-vocabulary items for fixed_vocab=True\n continue\n\n\n j_indices.extend(feature_counter.keys())\n values.extend(feature_counter.values())\n indptr.append(len(j_indices))\n\n if not fixed_vocab:\n # disable defaultdict behaviour\n vocabulary = dict(vocabulary)\n if not vocabulary:\n raise ValueError(\"empty vocabulary; perhaps the documents only\"\n \" contain stop words\")\n\n if indptr[-1] > np.iinfo(np.int32).max: # = 2**31 - 1\n if _IS_32BIT:\n raise ValueError(('sparse CSR array has {} non-zero '\n 'elements and requires 64 bit indexing, '\n 'which is unsupported with 32 bit Python.')\n .format(indptr[-1]))\n indices_dtype = np.int64\n\n else:\n indices_dtype = np.int32\n \n j_indices = np.asarray(j_indices, dtype=indices_dtype)\n indptr = np.asarray(indptr, dtype=indices_dtype)\n \n #print (vocabulary)\n X = sp.csr_matrix((values, j_indices, indptr),\n shape=(len(indptr) - 1, len(vocabulary)),\n dtype=np.float32)\n X.sort_indices() \n \n self.vocabulary_calculated = vocabulary\n\n return vocabulary, X","def analyzeFile(filename): \n fileData = open(filename, encoding=\"utf-8\") # open the file\n \n counts = {}\n\n for line in fileData:\t\t # iterates over every line of the file\n words = line.split() # turns each line into a list\n for word in words: #iterates over the words in each line list\n word = word.lower().strip(string.whitespace+string.punctuation)\n if len(word) > 0: #make sure word is longer than 0 before adding it to the dictionary\n counts[word] = counts.get(word, 0) + 1 #look up if the dictionary has that word and if not then it'll add that word with the value 0 associated with it and then add one to that, if it has seen it it'll add 1 to the value stored in the counts dictionary\n #when it gets here for the first line it goes back up to the top and repeats for the 2nd line\n mostCommonWord = [word]\n leastCommonWord = [word]\n shortestWord = [word]\n longestWord = [word]\n \n for item in counts:\n if counts[mostCommonWord[0]] < counts[item]:\n mostCommonWord = [item]\n elif counts[mostCommonWord[0]] == counts[item]:\n mostCommonWord.append(item)\n if counts[leastCommonWord[0]] > counts[item]:\n leastCommonWord = [item]\n elif counts[leastCommonWord[0]] == counts[item]:\n leastCommonWord.append(item)\n if len(shortestWord[0]) > len(item):\n shortestWord = [item] \n elif len((shortestWord[0])) == len(item):\n shortestWord.append(item)\n if len(longestWord[0]) < len(item):\n longestWord = [item]\n elif len(longestWord[0]) == len(item):\n longestWord.append(item)\n \n return (mostCommonWord, leastCommonWord, shortestWord, longestWord)","def extractWords(self, inputDataset):\n reviewFile = open(inputDataset, \"r\", encoding=\"utf-8-sig\")\n for record in reviewFile:\n record = record.strip().split(\"\\t\") # tab-delimited .txt file\n self.addUnigrams(int(record[0]), record[1])\n reviewFile.close()","def test_counts(self):\n lines, words, chars = analyze_text(self.filename)\n self.assertEqual(lines, 4)\n self.assertEqual(words, 8)\n self.assertEqual(chars, 36)","def count_ngrams(self, corpus):\n \n self.unigramcounts = {} # might want to use defaultdict or Counter instead\n self.bigramcounts = {} \n self.trigramcounts = {} \n\n self.total = 2\n ##Your code here\n\n for sentence in corpus:\n temp_1 = get_ngrams(sentence,1)\n temp_2 = get_ngrams(sentence,2)\n temp_3 = get_ngrams(sentence,3)\n for i in range(len(temp_1)):\n if temp_1[i] in self.unigramcounts:\n self.unigramcounts[temp_1[i]] += 1\n else:\n self.unigramcounts[temp_1[i]] = 1\n self.total += 1\n\n for i in range(len(temp_2)):\n if temp_2[i] in self.bigramcounts:\n self.bigramcounts[temp_2[i]] += 1\n else:\n self.bigramcounts[temp_2[i]] = 1\n\n for i in range(len(temp_3)):\n if temp_3[i] in self.trigramcounts:\n self.trigramcounts[temp_3[i]] += 1\n else:\n self.trigramcounts[temp_3[i]] = 1\n return","def word_frequency():\n\n song = open(\"data/yellow_submarine.txt\")\n d = dict()\n for line in song:\n line = line.strip()\n line = line.lower()\n punctuations = \"\"\"!()-[]{};:'\"\\,<>./?@#$%^&*_~\"\"\" # remove punctuation https://www.programiz.com/python-programming/examples/remove-punctuation\n no_punct = \"\" # remove punctuation\n for char in line: # remove punctuation\n if char not in punctuations: # remove punctuation\n no_punct = no_punct + char # remove punctuation\n words = line.split(\" \")\n for word in words:\n d[word] = d.get(word, 0) + 1\n return d","def _count(self):\n words = [word.lower() for word in self.corpus.words()]\n bigrams_words = bigrams(words)\n for bigram in bigrams_words:\n self._bigrams[bigram] += 1","def cleanCsv(): \n\n count_neutral = 0\n count_sad = 0\n count_angry = 0\n count_happy = 0\n\n count_session_neutral = 0 \n\n for column_values in raw_data:\n\n if significant_data.fieldnames is None:\n dh = dict((h, h) for h in raw_data.fieldnames)\n significant_data.fieldnames = raw_data.fieldnames\n significant_data.writerow(dh)\n\n if column_values['AOI[Sad_Right]Hit'] == '1':\n significant_data.writerow(column_values)\n count_sad = count_sad + 1\n\n if column_values['AOI[Neutral_Left]Hit'] == '1':\n significant_data.writerow(column_values)\n count_neutral = count_neutral + 1\n\n if column_values['AOI[Neutral_Left]Hit_0'] == '1':\n significant_data.writerow(column_values)\n count_neutral = count_neutral + 1\n\n if column_values['AOI[Neutral_Right]Hit'] == '1':\n significant_data.writerow(column_values)\n count_neutral = count_neutral + 1\n\n if column_values['AOI[Angry_Left]Hit'] == '1':\n significant_data.writerow(column_values)\n count_angry = count_angry + 1\n\n if column_values['AOI[Neutral_Right]Hit_0'] == '1':\n significant_data.writerow(column_values)\n count_neutral = count_neutral + 1\n\n if column_values['AOI[Happy_Right]Hit'] == '1':\n significant_data.writerow(column_values)\n count_happy = count_happy + 1\n\n if column_values['AOI[Neutral_Left]Hit_1'] == '1':\n significant_data.writerow(column_values)\n count_neutral = count_neutral + 1\n\n if column_values['AOI[Happy_Left]Hit'] == '1':\n significant_data.writerow(column_values)\n count_happy = count_happy + 1\n\n if column_values['AOI[Neutral_Right]Hit_1'] == '1':\n significant_data.writerow(column_values)\n count_neutral = count_neutral + 1\n\n if column_values['AOI[Sad_Left]Hit'] == '1':\n significant_data.writerow(column_values)\n count_sad = count_sad + 1\n\n if column_values['AOI[Neutral_Right]Hit_2'] == '1':\n significant_data.writerow(column_values)\n count_neutral = count_neutral + 1\n\n if column_values['AOI[Angry_Right]Hit'] == '1':\n significant_data.writerow(column_values)\n count_angry = count_angry + 1\n\n if column_values['AOI[Neutral_Left]Hit_2'] == '1':\n significant_data.writerow(column_values)\n count_neutral = count_neutral + 1\n\n return {\n 'count_neutral': count_neutral,\n 'count_sad': count_sad,\n 'count_angry': count_angry,\n 'count_happy': count_happy,\n }","def count_ngrams(self, corpus):\n \n self.unigramcounts = defaultdict(int)\n self.bigramcounts = defaultdict(int)\n self.trigramcounts = defaultdict(int)\n\n self.sentence_counts = 0\n self.word_count = 0\n\n for line in corpus:\n sequence = line\n self.sentence_counts +=1\n\n unigrams = get_ngrams(sequence, n=1)\n for gram in unigrams:\n self.word_count += 1\n self.unigramcounts[gram] +=1\n\n bigrams = get_ngrams(sequence, n=2)\n for gram in bigrams:\n self.bigramcounts[gram] +=1\n\n trigrams = get_ngrams(sequence, n=3)\n for gram in trigrams:\n self.trigramcounts[gram] +=1\n\n #self.unigramcounts[('START')] = self.sentence_counts *2\n self.bigramcounts[('START', 'START')] = self.sentence_counts\n\n #return self","def count_syllables(words):\n\n\n count = 0\n\n for word in words:\n word_count = count_syllables_in_word(word)\n count = count + word_count\n return count","def word_frequency( tokenized, dic ):\n print( 'computing word frequencies' )\n start = time.time()\n for i, text in enumerate( tokenized ):\n for token in text:\n if token not in dic:\n dic[ token ] = 1\n else:\n dic[ token ] += 1\n if i % 10000 == 0:\n sys.stdout.write( '\\rprocessed : {}/{} reviews in {}s'.format( i, NO_REVIEWS, time.time() - start ) )\n sys.stdout.write( '\\rprocessed : {}/{} reviews in {}s\\n'.format( i, NO_REVIEWS, time.time() - start ) )","def count_same_words(cuisine_file, menu):\n\n cuisine_list = separate_words(cuisine_file)\n \n same_word_count = 0\n \n for i in cuisine_list:\n for j in menu:\n if i == j:\n same_word_count += 1\n \n return same_word_count","def count_words(self, contents):\n wordCounts = {}\n for i in self.ngramCounts:\n if i == 0: # want the default to be the size of the corpus\n total = 0\n for line in contents:\n words = line.split(\" \")\n words = [ w.strip() for w in words if w] #remove nulls\n for word in words:\n if word:\n total += 1\n wordCounts[i] = defaultdict(lambda: total)\n continue\n else:\n counts = defaultdict(lambda: 0)\n for line in contents:\n words = line.split(\" \")\n words = [ w.strip() for w in words if w] #remove nulls\n for k, word in enumerate(words): \n if k < (i-1) or not word:\n continue\n key = \"\"\n for j in range(k-i+1, k+1):\n key += words[j] + \" \"\n counts[key.strip()] += 1\n wordCounts[i] = counts\n return wordCounts","def __parse_corpus(self, corpus):\n corpus = self.__handle_corpus_unkwon_words(corpus)\n start_token = ' '.join([NGramModel.START_SENTENCE_TOKEN]*(self.__n-1))\n word_list = corpus.replace(NGramModel.START_SENTENCE_TOKEN, start_token).split()\n \n for n in range(1, self.__n+1): \n self.__ngram_counts[n] = {}\n for ngram, count in Counter(self.__generate_n_grams(word_list, n)).items():\n self.__ngram_counts[n][' '.join(ngram)] = count","def train(self, corpus):\n for sentence in corpus.corpus:\n for datum in sentence.data: \n self.unigramCounts[datum.word] += 1\n self.totalCount += 1","def annotate_tsv_freq(in_tsv_gz,annotation_tsv):\n sys.stderr.write(\"Reading TSV file ...\\n\")\n nicollo = pd.read_csv(BOLLI, sep=\"\\t\")\n nicollo = nicollo.iloc[:,[1,2,4,5,23]]\n nicollo_counts = nicollo.groupby(['CHR','START'])['MT'].count()\n nol_var = nicollo.drop(['WT','MT'], axis = 1) \n nol_var = nol_var.set_index(['CHR', 'START'])\n\n #nicollo_counts = nicollo.groupby([\"CHR\",\"START\",\"WT\",\"MT\"]).size().reset_index(name=\"count\")\n #nicollo_counts = nicollo_counts[[\"CHR\", \"START\",\"count\"]].set_index(['CHR','START'])\n\n mmrf = pd.read_csv('/ifs/res/leukgen/home/yellapav/MMRF/MMRF_CoMMpass_IA9_All_Canonical_Variants.txt', sep=\"\\t\")\n mmrf=mmrf.iloc[:,[0,1,2,4,5,19,23]]\n mmrf=mmrf.drop_duplicates()\n\n mmrfM=mmrf.groupby(['CHROM','POS'])['GEN[1].AR'].median()\n mmrfC=mmrf.groupby(['CHROM','POS'])['GEN[1].AR'].count()\n mmrfQ25=mmrf.groupby(['CHROM','POS'])['GEN[1].AR'].quantile(q=0.25)\n mmrfQ75=mmrf.groupby(['CHROM','POS'])['GEN[1].AR'].quantile(q=0.75)\n \n\n #anno_tsv = pd.read_csv(annotation_tsv, comment='#',sep=\"\\t\")\n anno_tsv = pd.read_csv(annotation_tsv, comment='#',sep=\"\\t\", low_memory=False)\n #anno_tsv[anno_tsv['FILTER'] == \"PASS\"]\n counts_tsv=anno_tsv.groupby([\"CHR\",\"START\",\"REF\",\"ALT\"]).size().reset_index(name=\"count\")\n counts_tsv=counts_tsv[[\"CHR\", \"START\",\"count\"]].set_index(['CHR','START'])\n counts_median=anno_tsv.groupby(['CHR','START'])['TARGET_VAF'].median()\n\n\n\n inFile = gzip.open(in_tsv_gz,'r')\n \n sys.stderr.write(\"Annotating ...\\n\")\n for record in inFile:\n record=record.decode(\"utf-8\")\n record=record.rstrip()\n recArr=record.split(\"\\t\")\n \n cl = [] \n freq = [] \n medVAF = [] \n Q25 = [] \n Q75 = [] \n positions = [] \n normal = \"0\" \n normalVAF = \"0\" \n bolli_cl = [] \n bolli_freq = [] \n bolli_positions = [] \n bolli_anno = [] \n flag = 0\n bolli_flag = 0\n if record.startswith(\"#\"):\n continue\n\n if recArr[0] == \"ID_VARIANT\":\n cl = \"MMRF_Class\"\n freq = \"MMRF_Frequency\"\n medVAF = \"MMRF_VAF\"\n Q25 = \"MMRF_Q25\"\n Q75 = \"MMRF_Q75\"\n positions = \"MMRF_Positions\"\n normal = \"Normals_Frequency\"\n normalVAF = \"Normals_median_VAF\"\n bolli_cl = \"Bolli_Class\"\n bolli_freq = \"Bolli_Frequency\"\n bolli_positions = \"Bolli_Positions\"\n bolli_anno = \"Bolli_Annotation\"\n record = [ record, cl, freq, medVAF, Q25, Q75, positions, bolli_cl, bolli_freq, bolli_anno, bolli_positions, normal, normalVAF ]\n record = (\"\\t\".join(record))\n print(record)\n continue\n\n try:\n chrom = str(recArr[3])\n pos = int(recArr[4])\n start = int(recArr[4]) - 9\n end = int(recArr[4]) + 9\n if (chrom, pos) in mmrfC.index:\n cl = \"genomic_exact\"\n freq = str(mmrfC.loc[(chrom,pos)])\n medVAF = str(mmrfM.loc[(chrom,pos)])\n Q25 = str(mmrfQ25.loc[(chrom,pos)])\n Q75 = str(mmrfQ75.loc[(chrom,pos)])\n positions = str(pos)\n record = [ record, cl, freq, medVAF, Q25, Q75, positions ]\n record = (\"\\t\".join(record))\n flag = 1\n if flag == 0:\n mmrfCsub=mmrfC.loc[chrom]\n if not mmrfCsub[(mmrfCsub.index >= start) & (mmrfCsub.index <= end)].empty:\n for i in mmrfCsub[(mmrfCsub.index >= start) & (mmrfCsub.index <= end)].index.values:\n cl = \"genomic_close\"\n freq.append(str(mmrfC.loc[(chrom,i)]))\n medVAF.append(str(mmrfM.loc[(chrom,i)]))\n Q25.append(str(mmrfQ25.loc[(chrom,i)]))\n Q75.append(str(mmrfQ75.loc[(chrom,i)]))\n positions.append(str(i))\n freq = (\":\".join(freq))\n medVAF = (\":\".join(medVAF))\n Q25 = (\":\".join(Q25))\n Q75 = (\":\".join(Q75))\n positions = (\":\".join(positions))\n record = [ record, cl, freq, medVAF, Q25, Q75, positions ]\n record = (\"\\t\".join(record))\n else:\n cl = \"NA\"\n freq = \"NA\"\n medVAF = \"NA\"\n Q25 = \"NA\"\n Q75 = \"NA\"\n positions = \"NA\"\n record = [ record, cl, freq, medVAF, Q25, Q75, positions ]\n record = (\"\\t\".join(record))\n\n\n except:\n cl = \"NA\"\n freq = \"NA\"\n medVAF = \"NA\"\n Q25 = \"NA\"\n Q75 = \"NA\"\n positions = \"NA\"\n record = [ record, cl, freq, medVAF, Q25, Q75, positions ]\n record = (\"\\t\".join(record))\n\n\n\n try:\n chrom = str(recArr[3])\n pos = int(recArr[4])\n start = int(recArr[4]) - 9\n end = int(recArr[4]) + 9\n if (chrom, pos) in nicollo_counts.index:\n bolli_cl = \"genomic_exact\"\n bolli_freq = str(nicollo_counts.loc[(chrom,pos)]) \n bolli_positions = str(pos)\n bolli_anno = str(nol_var.loc[chrom, pos]['Variant_class'].values[0])\n record = [ record, bolli_cl, bolli_freq, bolli_anno, bolli_positions ]\n record = (\"\\t\".join(record))\n bolli_flag = 1\n\n\n if bolli_flag == 0: \n nicollo_counts_sub=nicollo_counts.loc[chrom]\n if not nicollo_counts_sub[(nicollo_counts_sub.index >= start) & (nicollo_counts_sub.index <= end)].empty:\n for i in nicollo_counts_sub[(nicollo_counts_sub.index >= start) & (nicollo_counts_sub.index <= end)].index.values:\n #if not nicollo_counts_sub.ix[start:end].empty:\n # for i in nicollo_counts_sub.ix[start:end].index.values:\n #print(\"XXXXXXX\",i, nicollo_counts_sub.loc[(chrom,i)], start, end)\n bolli_cl = \"genomic_close\"\n bolli_freq.append(str(nicollo_counts.loc[(chrom,i)]))\n bolli_anno.append(str(nol_var.loc[(chrom,i)]['Variant_class'].values[0]))\n bolli_positions.append(str(i))\n bolli_freq = (\":\".join(bolli_freq))\n bolli_positions = (\":\".join(bolli_positions))\n bolli_anno = (\":\".join(bolli_anno))\n record = [ record, bolli_cl, bolli_freq, bolli_anno, bolli_positions ]\n record = (\"\\t\".join(record))\n else:\n bolli_cl = \"NA\"\n bolli_freq = \"NA\"\n bolli_positions = \"NA\"\n bolli_anno = \"NA\"\n record = [ record, bolli_cl, bolli_freq, bolli_anno, bolli_positions ]\n record = (\"\\t\".join(record))\n\n\n except:\n bolli_cl = \"NA\"\n bolli_freq = \"NA\"\n bolli_anno = \"NA\"\n bolli_positions = \"NA\"\n record = [ record, bolli_cl, bolli_freq, bolli_anno, bolli_positions ]\n record = (\"\\t\".join(record))\n\n\n normal = \"0\"\n normalVAF = \"0\"\n try:\n chrom=str(recArr[3])\n pos=int(recArr[4])\n normal = counts_tsv.loc[(chrom,pos),\"count\"]\n normal = normal.ix[0]\n normal = str(normal)\n\n normalVAF = str(counts_median.loc[(chrom,pos)])\n\n record = [ record, normal, normalVAF ]\n record = (\"\\t\".join(record))\n print(record)\n\n except:\n normal = \"0\"\n normalVAF = \"0\"\n record = [ record, str(normal), str(normalVAF) ]\n record = (\"\\t\".join(record))\n print(record)","def word_analogy(self):\n data = open(\"data/word_analogy_subset.en.ar.txt\").read().split('\\n')\n data = [x for x in data if len(x.split()) == 4]\n cnt = 0\n keys = list(self.embeddings_index.keys())\n vectors = np.array(list(self.embeddings_index.values()))\n norms = np.linalg.norm(vectors, axis=1)\n for i in data:\n i = self.preprocessor(i).split()\n try:\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\n except:\n continue\n unit = v / np.linalg.norm(v)\n dists = np.dot(vectors, unit) / norms\n best = np.argpartition(-dists, 10)[:10 + 1]\n best = best.take(np.argsort((-dists).take(best)))\n result = [(keys[sim], float(dists[sim]))\n for sim in best]\n sbv = result[:10]\n for j in sbv:\n if j[0] == i[3]:\n cnt += 1\n return cnt/ len(data)","def _get_num_syllables(doc: Doc, min_syllables: int = 1):\n text = (word for word in doc if not word.is_punct and \"'\" not in word.text)\n syllables_per_word = tuple(syllapy.count(word.text) for word in text)\n return sum(c for c in syllables_per_word if c >= min_syllables)","def count_words_and_dublicates(novel):","def __yago_counts(self):\n\n num_lines = 0\n print(\"Calculating Yago occurrences\")\n custom_freq = {}\n with open(\n os.path.join(self.base_url, \"generic/p_e_m_data/aida_means.tsv\"),\n \"r\",\n encoding=\"utf-8\",\n ) as f:\n for line in f:\n num_lines += 1\n\n if num_lines % 5000000 == 0:\n print(\"Processed {} lines.\".format(num_lines))\n\n line = line.rstrip()\n line = unquote(line)\n parts = line.split(\"\\t\")\n mention = parts[0][1:-1].strip()\n\n ent_name = parts[1].strip()\n ent_name = ent_name.replace(\"&\", \"&\")\n ent_name = ent_name.replace(\""\", '\"')\n\n x = ent_name.find(\"\\\\u\")\n while x != -1:\n code = ent_name[x : x + 6]\n replace = unicode2ascii(code)\n if replace == \"%\":\n replace = \"%%\"\n\n ent_name = ent_name.replace(code, replace)\n x = ent_name.find(\"\\\\u\")\n\n ent_name = self.wikipedia.preprocess_ent_name(ent_name)\n if ent_name in self.wikipedia.wiki_id_name_map[\"ent_name_to_id\"]:\n if mention not in custom_freq:\n custom_freq[mention] = {}\n ent_name = ent_name.replace(\" \", \"_\")\n if ent_name not in custom_freq[mention]:\n custom_freq[mention][ent_name] = 1\n\n return custom_freq","def process(self):\n\n linelang = defaultdict(int)\n wordlang = defaultdict(int)\n\n linefont = defaultdict(int)\n wordfont = defaultdict(int)\n\n inputfiles = self.input_files\n for input_file in inputfiles:\n\n alignurl = input_file.url\n pcgts = parse(alignurl, True)\n page = pcgts.get_Page()\n regions = page.get_TextRegion()\n\n for region in regions:\n lines = region.get_TextLine()\n\n for line in lines:\n try:\n llang = line.primaryLanguage\n linelang[llang] += 1\n except TypeError:\n pass\n\n try:\n lfont = line.fontFamily\n linefont[lfont] += 1\n except TypeError:\n pass\n\n words = line.get_Word()\n for word in words:\n try:\n wlang = word.language\n wordlang[wlang] += 1\n except TypeError:\n pass\n\n try:\n wfont = word.get_TextStyle().fontFamily\n wordfont[wfont] += 1\n except TypeError:\n pass\n\n #predominant language\n try:\n lang = max(linelang, key=lambda k: linelang[k])\n except TypeError:\n try:\n lang = max(wordlang, key=lambda k: wordlang[k])\n except TypeError:\n lang = 'German'\n\n #predominant font\n try:\n font = max(linefont, key=lambda k: linefont[k])\n except TypeError:\n try:\n font = max(wordfont, key=lambda k: wordfont[k])\n except TypeError:\n font = 'Antiqua'\n\n\n print(lang)\n print(font)","def update_syllable_count(word, syll_count):\n\n syllables = word.split('-')\n for i in range(1, 4):\n for j in range(len(syllables) - i + 1):\n gram = '-'.join(syllables[j: j + i])\n count = syll_count.setdefault(gram, 0)\n syll_count[gram] = count + 1","def corpora_stats(output):\n igFiles = []\n for root, directories, filenames in os.walk(output + \"/ig/\"):\n for filename in filenames:\n igFiles.append(os.path.join(root, filename))\n igFiles = filter(lambda x: \".txt\" in x, igFiles)\n words = []\n for file in igFiles:\n fileH = open(file, \"r\")\n words = words + fileH.read().split(\" \")\n print(\"Number of words in IG corpus: {}\".format(len(words)))\n print(\"Vocabulary size of IG corpus: {}\".format(len(set(words))))","def __init__(self, n, sents):\n assert n > 0\n self._n = n\n print(\"Counting...\")\n count = defaultdict(int)\n while n >= 0:\n for sent in sents:\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\n s.insert(0, \"<s>\")\n s.append(\"</s>\")\n for i in range(len(s) - n + 1):\n count[tuple(s[i:i + n])] += 1\n n -= 1\n count[()] = count[()] - count[('<s>',)] - count[\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\n self._count = count\n print(\"Computing vocabulary...\")\n self._voc = voc = set()\n for sent in sents:\n voc = voc.union(set(sent))\n voc.add('</s>')\n self._voc = voc\n self._V = len(voc) # vocabulary size\n print(\"Done\")","def process_corpus(args):\n\n fs = open(args.input,'r')\n out = list()\n for line in fs:\n blob = TextBlob(line.strip())\n result_info = dict()\n result_info\n result_info['correct'] = str(blob.correct())\n if args.parse :\n result_info['parse'] = get_parsed_text(blob)\n if args.tokenize:\n result_info['tokenize'] = get_tokenizer_result(blob)\n if args.sentiment:\n result_info['sentiment'] = analyze_sentiment(blob)\n if args.sentence_sentiment:\n result_info['sentence_sentiment'] = analyze_sentence_sentiment(blob)\n if args.noun_phrase:\n result_info['noun_phrase'] = get_noun_phrases(blob)\n if args.pos:\n result_info['pos'] = get_pos_tags(blob)\n\n out.append(result_info)\n print out\n json.dump(out,open('out.json','w'))\n fs.close()\n print '******************************* Execution completed *********************************'","def tokenize_and_split_bis(sms_file):\n \n dic = {}\n list1 = []\n list2 = []\n list3 = []\n list4 = []\n i = -1\n document = 0\n terms = 0\n new_document = True\n ham = True\n for line in open(sms_file, 'r').readlines():\n w = []\n document += 1\n new_document = True\n for word in line.split():\n i = i + 1\n if word == \"ham\":\n ham = True\n i = i - 1\n elif word == \"spam\":\n ham = False\n i = i - 1\n else:\n if word not in dic:\n dic[word] = i\n w.append(dic[word])\n list3.append(1)\n list4.append(1)\n new_document = False\n terms += 1\n else : \n i = i - 1\n w.append(dic[word])\n list4[dic[word]] += 1\n terms += 1\n if new_document: \n list3[dic[word]] += 1\n new_document = False\n \n if ham and w !=[]:\n list2.append(w)\n elif ham == False and w !=[]:\n list1.append(w)\n\n moy = 0\n len_dic = len(dic.keys())\n list5 = [0 for x in range(len_dic)]\n for key in dic.keys():\n if list4[dic[key]] > 0:\n tf = list4[dic[key]] / terms\n idf = math.log(document / list3[dic[key]])\n tfIdf = tf * idf\n list5[dic[key]] = tfIdf\n # print(\"the word \" + str(key) + \" appairs \" + str(list4[dic[key]]) + \" times.\")\n # print(\"his frequency is \" + str(list4[dic[key]] / terms) )\n # print(\"the word \" + str(key) + \" appairs \" + str(list3[dic[key]]) + \" times in each document.\")\n # print(\"his frequency is \" + str(idf))\n # print(\"utility \" + str(tfIdf))\n moy += tfIdf\n \n moy = moy / len_dic \n # print(moy)\n dic_bis = {}\n i = -1\n for key in dic.keys():\n value = list5[dic[key]]\n # print(str(value))\n if (value > oracle * moy):\n i += 1\n dic_bis[key] = i\n # else:\n # print(\"not pass \" + key + \" \" + str(value))\n \n \n # print(dic_bis == dic)\n # print(dic)\n return dic_bis,list1,list2","def estimate(word):\n parts = re.split(r'[^aeiouy]+', word)\n valid_parts = []\n\n for part in parts:\n if part != '':\n valid_parts.append(part)\n\n syllables = 0\n\n for p in re_subsyllables:\n if p.match(word):\n syllables -= 1\n\n for p in re_addsyllables:\n if p.match(word):\n syllables += 1\n\n syllables += len(valid_parts)\n\n if syllables <= 0:\n syllables = 1\n\n return syllables","def countsyllables_en(word):\r\n\tif not word:\r\n\t\treturn 0\r\n\r\n\t# Remove final silent 'e'\r\n\tif word[-1] == \"e\":\r\n\t\tword = word[:-1]\r\n\r\n\t# Check for a cached syllable count\r\n\tif word in fallback_cache:\r\n\t\treturn fallback_cache[word]\r\n\r\n\t# Count vowel groups\r\n\tresult = 0\r\n\tprev_was_vowel = False\r\n\tfor char in word:\r\n\t\tis_vowel = char in VOWELS or char == 'y'\r\n\t\tif is_vowel and not prev_was_vowel:\r\n\t\t\tresult += 1\r\n\t\tprev_was_vowel = is_vowel\r\n\r\n\t# Add & subtract syllables\r\n\tfor r in fallback_addsyl:\r\n\t\tif r.search(word):\r\n\t\t\tresult += 1\r\n\tfor r in fallback_subsyl:\r\n\t\tif r.search(word):\r\n\t\t\tresult -= 1\r\n\r\n\t# Cache the syllable count\r\n\tfallback_cache[word] = result\r\n\r\n\treturn result","def train(self, corpus): \n for sentence in corpus.corpus:\n prev_word = None\n for datum in sentence.data:\n word = datum.word\n self.unigram_count[word] += 1\n if prev_word != None:\n self.bigram_count[prev_word][word] += 1\n prev_word = word\n \n self.vocabulary_size = len(self.unigram_count)\n self.num_words = sum(self.unigram_count.values())","def analyze_text (self, testing_string): \n self.length = len(self.testing_string)\n self.total_words = (self.testing_string).split()\n self.total_unique_words = set(self.total_words)\n\n self.total_characters = (int)(0)\n for ch in self.testing_string :\n if(ch.isspace() != True):\n self.total_characters = self.total_characters + 1 \n\n self.total_unique_characters = set(self.testing_string)\n \n Linguist.about_given_string[\"Length\"] = self.length\n Linguist.about_given_string[\"Total_words\"] = len(self.total_words)\n Linguist.about_given_string[\"Total_unique_words\"] = len(self.total_unique_words)\n Linguist.about_given_string[\"Total_characters\"] = self.total_characters\n Linguist.about_given_string[\"Total_unique_characters\"] = len(self.total_unique_characters)","def num_syllables(self, word):\n \"\"\"\n using the logic of vowel counting, count all vowels in the pronunciations\n \"\"\"\n dictionary = self._pronunciations;\n # check if word is present in the CMU dictionary\n if word in dictionary :\n word_pronunciations = dictionary[word.lower()]\n else :\n return 1\n \n vowels = ['A', 'E', 'I', 'O', 'U']\n \n ## find the shorter pronunciation for word\n shorter_arr = [];\n for pronunciation in word_pronunciations :\n if len(pronunciation) > len(shorter_arr) : shorter_arr = pronunciation\n \n num_length = 0\n \n for phoneme in shorter_arr :\n if phoneme[:1] in vowels : num_length += 1\n \n return num_length","def train(self, corpus):\n lastToken = \"#\"\n for sentence in corpus.corpus:\n for datum in sentence.data:\n token = datum.word\n self.reverseBigramCount[token][lastToken] += 1\n self.bigramCount[lastToken][token] += 1\n self.unigramCount[token] += 1\n self.total += 1\n lastToken = token","def syllable_dict():\n counts = dict()\n \n with open('data/Syllable_dictionary.txt') as file:\n for line in file:\n arr = line.split(' ', 1)\n if 'E' in arr[1]:\n cts = arr[1].split(' ', 1)\n counts[arr[0].strip('\\'')] = int(cts[1][0])\n counts[(arr[0].strip('\\'') + \"_\")] = int(cts[0][1])\n else:\n counts[arr[0].strip('\\'')] = int(arr[1][0])\n return counts","def train(self, corpus):\n for sentence in corpus.corpus:\n cleanSentence = sentence.cleanSentence()\n for datum in cleanSentence.data:\n token = datum.word\n self.unigramCounts[token] = self.unigramCounts[token] + 1\n self.total += 1\n\n i = 0\n while i < len(sentence.data) - 1:\n token = str(cleanSentence.get(i))\n self.followingWords[token].add(str(cleanSentence.get(i+1)))\n i += 1\n\n i = 1\n while i < len(sentence.data):\n bigram = str(cleanSentence.get(i-1)) + \" \" + str(cleanSentence.get(i))\n self.bigramCounts[bigram] = self.bigramCounts[bigram] + 1\n\n self.precedingWords[str(cleanSentence.get(i))].add(str(cleanSentence.get(i-1)))\n i += 1\n self.precedingWordsTotal = sum(map(lambda x: len(x), self.precedingWords.values()))\n\n i = 2\n while i < len(sentence.data):\n trigram = str(cleanSentence.get(i-2)) + \" \" + str(cleanSentence.get(i-1)) + \" \" + str(cleanSentence.get(i))\n self.trigramCounts[trigram] = self.trigramCounts[trigram] + 1\n i += 1\n\n #print('precedingWords')\n #print(self.precedingWords)\n #print('followingWords')\n #print(self.followingWords)\n #print('unigrams')\n #print(self.unigramCounts)\n #print('bigrams')\n #print(self.bigramCounts)\n\n #self.discount(self.trigramCounts)\n #self.discount(self.bigramCounts)\n #self.discount(self.unigramCounts)","def findSubcorpora():\n counterTwo = 0\n\n with open('bc.processed2.csv', 'r') as readfile:\n for line in readfile:\n counterTwo += 1\n if re.match('^<subcorpus', line):\n print(str(counterTwo) + '\\t' + line + '\\n')","def get_feature_set_SB(tweet):\n #pos-tag frequencies\n# print \"Tagged words in tweet: \", tweet.tagged_words\n pos_tag_freq = {}\n additional_freq = {}\n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# if tag=='PRtinf':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJS':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJ':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='NP':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='DET':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='P':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n if tag in ADJECTIVES:\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\n elif tag in ADVERBS: \n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\n elif tag in PRONOUNS:\n additional_freq['pronoun'] = 1\n except KeyError:\n continue\n# print \"Tag frequencies: \", pos_tag_freq\n for key in pos_tag_freq.keys():\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \n #Number of exclamation marks, number of emoticons,\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\n if emoticons>0:\n additional_freq['emoticons'] = emoticons*1.0\n if tweet.nrof_exclamations>0:\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\n \n# print \"Additional frequencies: \", additional_freq\n# raw_input(\"Continue?\")\n \n #Concatenate the dicts\n features= dict(pos_tag_freq.items() + additional_freq.items())\n# print \"All features: \", features\n# raw_input(\"Continue?\")\n return features","def count_syllables(book):\n d = dict(cmudict.entries())\n with open(book, 'r') as myfile:\n booky = myfile.read().lower()\n tokenized_book = nltk.word_tokenize(booky)\n\n count = 0\n for word in tokenized_book:\n count += ( nsly(word, d))\n\n return count","def setCounts(self):\n N=len(self.y)\n self.counts=np.zeros(len(self.y))\n self.idf=np.zeros(len(self.y))\n for i in range(0,len(self.counts)):\n for word in self.qtext:\n wc=self.atext[i].count(word)\n self.counts[i]+=wc\n if wc>0:\n d=0\n for sentence in self.atext:\n if word in sentence:\n d+=1\n self.idf[i]+=wc*np.log(N/d)","def analyze_social_patterns(input_file):\n # First read in the spelling variants\n # standard, non standard\n # us, uk spelling\n standard_non_standard_pairs = util.read_variants_from_file(input_file)\n all_forms = set()\n all_forms = all_forms.union(standard_non_standard_pairs.keys())\n all_forms = all_forms.union(standard_non_standard_pairs.values())\n \n # Keeping track of stats\n subreddit_count_standard = {}\n subreddit_count_non_standard = {}\n\n # Data\n sentences_metadata = DataWrapper.DataWrapperGzipMulti(config.REDDIT_PROCESSED_DATA,\n config.REDDIT_METADATA_DATA)\n \n for sentence, metadata in sentences_metadata:\n\n author, author_text, subreddit, link = metadata.split(\"\\t\")\n\n # Now check for tokens in our list\n for token in sentence:\n if token in all_forms:\n\n if subreddit not in subreddit_count_standard:\n subreddit_count_standard[subreddit] = 0\n subreddit_count_non_standard[subreddit] = 0\n\n # standard or US spelling\n if token in standard_non_standard_pairs:\n subreddit_count_standard[subreddit] += 1\n else:\n subreddit_count_non_standard[subreddit] += 1\n\n # Print out stats\n output_file_name = os.path.splitext(os.path.basename(input_file))[0]\n with open(output_file_name + \"_subreddits_distr.txt\", \"w\") as output_file:\n for subreddit, count in subreddit_count_standard.items():\n output_file.write(\"%s\\t%s\\t%s\\n\" % (subreddit, count, subreddit_count_non_standard[subreddit]))","def train(self, corpus):\n\n\n temp = \"\"\n for sentence in corpus.corpus:\n\n i = 0\n for datum in sentence.data:\n # print str(sentence.data)\n self.total=self.total+1\n token = datum.word\n self.unigramCounts[token] = self.unigramCounts[token] + 1\n if (i == 0):\n temp = datum.word\n i = i + 1\n continue\n\n i = i + 1\n\n key = temp + \",\" + token\n self.bigramCounts[key] = self.bigramCounts[key] + 1\n # print token\n temp = token\n\n pass","def getCounter(self):\n word_count, noun_word_count = Counter(), Counter()\n word_rating, noun_word_rating = defaultdict(list), defaultdict(list)\n docs = self.nlp.pipe(\n self.docs, n_process=1, disable=self.disablelayers)\n \n\n for index, doc in enumerate(docs):\n for token in doc:\n if not token.is_stop and not token.is_punct and token.pos_ in self.pos:\n if token.pos_ == 'PROPN':\n word_count[token.lemma_] += 1\n word_rating[token.lemma_].append(self.ratings[index])\n else:\n noun_word_count[token.lemma_] += 1\n noun_word_rating[token.lemma_].append(self.ratings[index])\n\n # if 0<=proper nouns<=5 found, add regular nouns\n if not word_count or len(word_count) <= 5:\n word_count += noun_word_count\n word_rating = {**word_rating, **noun_word_rating}\n \n word_color = {word: self.getColor(\n ratings)[1] for word, ratings in word_rating.items()}\n word_sentiment = {word: self.getColor(\n ratings)[0] for word, ratings in word_rating.items()}\n\n return word_count, word_color, word_sentiment","def count_syllables_in_word(word):\n\n count = 0\n\n endings = '!,;.?:'\n last_char = word[-1]\n\n if last_char in endings:\n processed_word = word[0:-1]\n else:\n processed_word = word\n\n\n if len(processed_word) <= 3:\n return 1\n if processed_word[-1] in 'Ee':\n processed_word = processed_word[0:-1]\n\n vowels = 'aeiouAEIOU'\n prev_char_was_vowel = False\n\n for char in processed_word:\n if char in vowels:\n if not prev_char_was_vowel:\n count += 1\n prev_char_was_vowel = True\n\n else:\n prev_char_was_vowel = False\n\n if processed_word[-1] in 'yY':\n count += 1\n \n\n return count","def main():\n token_dict_dict = {}\n all_dict = {}\n pronoun_proportion_list = []\n tag = 'PRP' # base tag for all pronouns, see 'https://www.clips.uantwerpen.be/pages/MBSP-tags' for more info\n\n for text in glob.glob(file_loc):\n file_title = os.path.basename(text).split('.')[0]\n\n with open(text, 'r') as f:\n speech = f.read()\n text_dict = {}\n\n try:\n #TextBlob goodness that tags all the words for me\n speech_blob = TextBlob(clean(speech))\n speech_blob.tags\n except:\n #for some reason Trump's address contained a unicode 128 character that I couldn't find\n #instead of getting rid of it in a single file, i decided to have an except that could catch that case in\n #all sitations and handle them accordingly\n\n #lets the user know that there was an issue, and that it's been handled\n print file_title,\n print \"contains unexpected unicode characters. they have been removed and the document has been processed\"\n\n #gets rid of all unicode characters. i could do this by default, but all the other files ran fine\n #so i didn't think it was worth it\n speech_blob = TextBlob(clean(speech.decode('unicode_escape').encode('ascii','ignore')))\n\n for token in speech_blob.tags:\n # builds the inital dictionary of data, only looks at words with a specified tag\n if tag in token[1]:\n try:\n text_dict[token[0]] += 1\n except:\n text_dict[token[0]] = 1\n try:\n all_dict[token[0]] += 1\n except:\n all_dict[token[0]] = 1\n #breaks the title into 3 pieces: number, president, date\n token_dict_dict[file_title] = text_dict\n partial_split, date = string.rsplit(file_title, '_', 1)\n num_pres, pres = string.split(partial_split, '_', 1)\n\n pronoun_proportion_list.append(\n (pres, date, total_to_proportion(pronoun_breakdown(token_dict_dict[file_title])))\n )\n create_pronoun_graph(sort_list_by_president_order(pronoun_proportion_list))","def get_vocabulary(text_fname, vocab_fname):\n with codecs.open(text_fname,'r','utf-8') as infile, \\\n codecs.open(vocab_fname,'w','utf-8') as outfile: \n\n count_map={}\n for line in infile:\n sent=line.strip().split(' ')\n for w in sent:\n count_map[w]=count_map.get(w,0.0)+1.0\n\n for w,c in count_map.iteritems(): \n outfile.write(u'{}|{}\\n'.format(w,c))","def getTextStatsFeat(text, stemmRequired = True,\r\n excludeStopwordsRequired = True):\r\n #length = len(text)\r\n sentenceCount = len(re.findall(\"[.?!]\", text))\r\n exclamationMarkCount = len(re.findall(\"[!]\", text))\r\n questionMarkCount = len(re.findall(\"[?]\", text))\r\n digitsCount = len(re.findall(\"[0-9]+\", text))\r\n text = text.replace(\",\", \" \").replace(\".\", \" \")\r\n cleanText = re.sub('[^a-zа-я0-9]', ' ', text.lower())\r\n wordCount = 0.0\r\n charCount = 0.0\r\n rusCharCount = 0.0\r\n engCharCount = 0.0\r\n if excludeStopwordsRequired:\r\n for w in cleanText.split():\r\n if len(w)>1 and w not in stopwords:\r\n if not (not stemmRequired or re.search(\"[0-9a-z]\", w)):\r\n w = stemmer.stem(w)\r\n wordCount += 1\r\n c, rus, eng = getWordCharCount(w)\r\n charCount += c\r\n rusCharCount += rus\r\n engCharCount += eng\r\n else:\r\n for w in cleanText.split():\r\n if len(w)>1:\r\n if not (not stemmRequired or re.search(\"[0-9a-z]\", w)):\r\n w = stemmer.stem(w)\r\n wordCount += 1\r\n c, rus, eng = getWordCharCount(w)\r\n charCount += c\r\n rusCharCount += rus\r\n engCharCount += eng\r\n # per sentence\r\n wordPerSentence = tryDivide(wordCount, sentenceCount)\r\n charPerSentence = tryDivide(charCount, sentenceCount)\r\n rusCharPerSentence = tryDivide(rusCharCount, sentenceCount)\r\n engCharPerSentence = tryDivide(engCharCount, sentenceCount)\r\n # per word\r\n charPerWord = tryDivide(charCount, wordCount)\r\n rusCharPerWord = tryDivide(rusCharCount, wordCount)\r\n engCharPerWord = tryDivide(engCharCount, wordCount)\r\n # ratio\r\n rusCharRatio = tryDivide(rusCharCount, charCount)\r\n engCharRatio = tryDivide(engCharCount, charCount)\r\n rusCharVsEngChar = tryDivide(rusCharCount, engCharCount)\r\n engCharVsRusChar = tryDivide(engCharCount, rusCharCount)\r\n \r\n stats = [\r\n sentenceCount,\r\n wordCount,\r\n charCount,\r\n rusCharCount,\r\n engCharCount,\r\n digitsCount,\r\n exclamationMarkCount,\r\n questionMarkCount,\r\n wordPerSentence,\r\n charPerSentence,\r\n rusCharPerSentence,\r\n engCharPerSentence,\r\n charPerWord,\r\n rusCharPerWord,\r\n engCharPerWord,\r\n rusCharRatio,\r\n engCharRatio,\r\n rusCharVsEngChar,\r\n engCharVsRusChar,\r\n ]\r\n statsFeat = \"\"\r\n for i,f in enumerate(stats):\r\n if f != 0:\r\n statsFeat += \"%s:%s \" % (i+1, f)\r\n statsFeat = statsFeat[:-1] \r\n return statsFeat","def get_text_frequencies(connection, feature, text_id):\n tindex2mtindex = {}\n findex2mfindex = {}\n word_counts = Counter()\n word_feature_pairs = set()\n text_token_count = 0\n unit_proj = {\n '_id': False,\n 'tokens.features.form': True\n }\n if feature != 'form':\n unit_proj['tokens.features.'+feature] = True\n db_cursor = connection.connection[Unit.collection].find(\n {'text': text_id, 'unit_type': 'line'},\n unit_proj\n )\n for unit in db_cursor:\n text_token_count += len(unit['tokens'])\n for token in unit['tokens']:\n cur_features = token['features']\n # use the form index as an identifier for this token's word\n # type\n cur_tindex = cur_features['form'][0]\n if cur_tindex not in tindex2mtindex:\n tindex2mtindex[cur_tindex] = len(tindex2mtindex)\n mtindex = tindex2mtindex[cur_tindex]\n # we want to count word types by matrix indices for faster\n # lookup when we get to the stage of counting up word type\n # occurrences\n word_counts[mtindex] += 1\n for cur_findex in cur_features[feature]:\n if cur_findex not in findex2mfindex:\n findex2mfindex[cur_findex] = len(findex2mfindex)\n mfindex = findex2mfindex[cur_findex]\n # record when a word type is associated with a feature type\n word_feature_pairs.add((mtindex, mfindex))\n csr_rows = []\n csr_cols = []\n for mtindex, mfindex in word_feature_pairs:\n csr_rows.append(mtindex)\n csr_cols.append(mfindex)\n word_feature_matrix = csr_matrix(\n (\n np.ones(len(csr_rows), dtype=np.bool),\n (np.array(csr_rows), np.array(csr_cols))\n ),\n shape=(len(tindex2mtindex), len(findex2mfindex))\n )\n # if matching_words_matrix[i, j] == True, then the word represented by\n # position i shared at least one feature type with the word represented\n # by position j\n matching_words_matrix = word_feature_matrix.dot(\n word_feature_matrix.transpose())\n\n mtindex2tindex = {\n mtindex: tindex for tindex, mtindex in tindex2mtindex.items()}\n freqs = {}\n coo = matching_words_matrix.tocoo()\n for i, j in zip(coo.row, coo.col):\n # since only matching tokens remain, the column indices indicate\n # which tokens match the token represented by row i; we need to\n # count up how many times each word appeared\n cur_token = mtindex2tindex[i]\n if cur_token not in freqs:\n freqs[cur_token] = word_counts[j]\n else:\n freqs[cur_token] += word_counts[j]\n for tok_ind in freqs:\n freqs[tok_ind] = freqs[tok_ind] / text_token_count\n return freqs","def get_word2freq_and_pos(self, files: List[str]) -> Tuple[Dict[str, int], List[str]]:\n word2freq = defaultdict(int)\n pos_list = []\n\n logger.info(\"Tokenization\")\n for file in files:\n logger.info(\"\\tReading file: {}\".format(file))\n with open(file, 'r') as f:\n for line in tqdm(f):\n line = line.strip()\n if line != \"\":\n for m in self.tokenize(line):\n word2freq[self.word_formatter(m)] += 1\n pos_list.append(pos_substitution_format(m))\n\n return word2freq, list(set(pos_list))","def word_count(self):\n print(self.words())\n return len(self.words())\n #count = 0\n #for lines in self.lines:\n # line = lines.strip(os.linesep)\n # wordslst = line.split()\n # count += len(wordslst)\n #return count\n #joined_string = ''.join(self.lines)\n #for word in joined_string:\n # if word != ' ' and word != '\\n' and word != '\\t':\n # count += 1\n #print('READ ME ––––––––––', self.lines)\n #print(joined_string)\n #print(line)\n #print(wordslst)\n #print(count)","def _counter(title_list):\n t = Tokenizer()\n words_count = defaultdict(int)\n words = []\n for title in title_list:\n tokens = t.tokenize(title)\n for token in tokens:\n pos = token.part_of_speech.split(',')[0]\n if pos == '名詞':\n words_count[token.base_form] += 1\n words.append(token.base_form)\n return words_count, words","def analyze(self, word_count_thresh):","def count_words_fast(text):\n skip = [\",\",\".\",\";\",\":\",\"'\",'\"']\n for ch in skip:\n text = text.replace('ch',\"\")\n \n word_counts = Counter(text.split(\" \"))\n return word_counts","def anlSentence(self, sentence):\n cleanStr = re.sub(self._wrdSeps, \" \",\n re.sub(self._stcSeps, \"\", sentence))\n for word in cleanStr.split():\n self._wordCounter[word] += 1\n self._totalWords += 1\n else:\n self._totalSentences += 1","def alice_in_wonderland():\n from collections import Counter\n with open(\"lib/alice_in_wonderland.txt\") as f:\n #~ table = maketrans(\" \",\" \")\n #~ wordlist = f.read().lower().translate(table, punctuation).split()\n # Translate actually performs fastest here but we use list comprehension\n # because we like it.\n wordlist = [i.lower() for i in f.read().split() if i.isalpha()]\n counted_words = Counter(wordlist)\n # Sort and write our counted wordlist to a new file:\n with open(\"lib/alice_counted.txt\", \"w\") as fout:\n length = 0\n for k, v in sorted(counted_words.items()):\n if len(k) > length:\n length = len(k)\n print length\n fout.write(k + \" \" + str(v) + \"\\n\")\n\n # 3 Solutions for counting characters (not words):\n #~ import operator\n #~ from string import lowercase, punctuation\n \n # 1: Reading the file into a string, then performing dictionary comprehension.\n #~ s = f.read().lower()\n #~ # Incredibly stupid and slow because it goes through the whole string\n #~ # with each iteration. DO NOT DO THIS.\n #~ L = {i: s.count(i) for i in s if i in lowercase}\n #~ L_sorted = sorted(L.iteritems(), key=operator.itemgetter(0))\n #~ print L_sorted\n\n # 2: Reading the file line by line into a dictionary.\n #~ d = {}\n #~ for i in f:\n #~ i = i.lower().strip()\n #~ i = [c for c in i if c in lowercase]\n #~ for char in i:\n #~ if char in d:\n #~ d[char] += 1\n #~ else:\n #~ d[char] = 1\n #~ keys = d.keys()\n #~ keys.sort()\n #~ for i in keys:\n #~ print (i, d[i]),\n\n # 3: Using Counter\n #~ s = [i for i in f.read().lower() if i in lowercase]\n #~ d = Counter(s)\n # Long version:\n #~ keys = sorted(d.keys())\n #~ for i in keys:\n #~ print (i, d[i]),\n #~ # Concise:\n #~ for k, v in sorted(d.items()): print (k, v),","def trainInternal():\n\n con_counts = Counter()\n deflike = Counter()\n\n for record in records:\n data = [re.split(\"\\t\", d) for d in re.split(\"\\n\", record)]\n tokens, tags = zip(*data)\n\n for i, token in enumerate(tokens):\n denom = len(token)\n for indices, f in fqs(token, 0.5): #perform analysis on one word at a time\n context, numer = internalContext(indices, token)\n if tags[i] != \"O\": #only want the named entities\n deflike[context] += f * numer/denom #need to normalize by word length\n con_counts[context] += f * numer/denom\n\n deflike = Counter({context: deflike[context]/con_counts[context] for context in deflike}) #perform division on each entry\n\n return deflike","def analyze(self, text):\n\n # start from 0 for each Analyser variable\n self.positives = 0\n self.negatives = 0\n\n # precise self text value\n self.text = text\n\n # declare a tokenased word\n tokenizer = nltk.tokenize.TweetTokenizer()\n tokens = tokenizer.tokenize(text)\n\n # indicate the length of list tokens\n size = len(tokens)\n\n # all the word stuff to ckeck\n for word in tokens:\n\n # chaque mots est converti en mot sans majuscule\n word = str.lower(word)\n\n linespos = [line.rstrip('\\n') for line in open('positive-words.txt')]\n linesneg = [line.rstrip('\\n') for line in open('negative-words.txt')]\n\n # check for positive or negative or neutral words\n if word in linespos:\n self.positives += 1\n elif word in linesneg:\n self.negatives += 1\n else:\n continue\n\n # score calculculated and reurned\n score = self.positives - self.negatives\n\n return score","def get_feature_set_SC(tweet, sentimentvalues):\n pos_tag_freq = {}\n additional_freq = {}\n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# if tag=='PRtinf':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJS':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJ':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='NP':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='DET':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='P':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n if tag in ADJECTIVES:\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\n elif tag in ADVERBS: \n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\n elif tag in PRONOUNS:\n additional_freq['pronoun'] = 1\n except KeyError:\n continue\n for key in pos_tag_freq.keys():\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \n #Number of exclamation marks, number of emoticons,\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\n if emoticons>0:\n additional_freq['emoticons'] = emoticons*1.0\n if tweet.nrof_exclamations>0:\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\n \n #Add lexicon values\n #total subjectivity score from word polarities, total objectivity score, number of subjective words, number of objective words, e\n sub_score = 0.0\n obj_score = 0.0\n nrof_subwords = 0\n nrof_objwords = 0\n for word in sentimentvalues.keys():\n if sentimentvalues[word][0]>0:\n sub_score = sub_score + sentimentvalues[word][0]\n nrof_subwords = nrof_subwords + 1\n if sentimentvalues[word][1]>0:\n sub_score = sub_score + sentimentvalues[word][1]\n nrof_subwords = nrof_subwords + 1\n if sentimentvalues[word][2]>0:\n obj_score = obj_score + sentimentvalues[word][2]\n nrof_objwords = nrof_objwords + 1\n if sub_score>0:\n additional_freq[\"sub_score\"] = sub_score+1.0\n if obj_score>0:\n additional_freq[\"obj_score\"] = obj_score+1.0\n if nrof_subwords>0:\n additional_freq[\"subjective_words\"] = nrof_subwords*1.0\n if nrof_objwords>0:\n additional_freq[\"objective_words\"] = nrof_objwords*1.0\n \n #Concatenate the dicts\n features= dict(pos_tag_freq.items() + additional_freq.items())\n \n return features","def corpus_statistics(corpus, d_corp):\n print('There are {} types of a total of {} tokens in the corpus.\\n' .format(number_types(corpus), corpus_length(corpus)))\n print('There average token length is {}.\\n' .format(average_length(corpus)))\n print('The longest token is {}.\\n' .format(longest_token(corpus)))\n print('The number of hapaxes is {} and represents the {} of the corpus.\\n.' .format(hapaxes(corpus), percentage(hapaxes(corpus), corpus_length(corpus))))\n print('The 10 most frequent types of the total tokens are {} and represent the {}%.\\n' .format(most_frequent(corpus), percentage_common_types(corpus))) \n print('The hapaxes present in each of the 9 partitions are {}.\\n' .format(hapaxes_parts(d_corp)))\n print('The percentage of hapaxes for each partition is {}.\\n' .format(percentage_hapaxes(d_corp, corpus)))\n plots(d_corp, corpus)\n print('\\nIn the tupla {}, the first element is the number of unique bigrams, and the second element is the percentage of unique bigrams from all the bigrams in the corpus. Similarly, in this tupla {}, the first element is the number of unique trigrams, and the second element is the percentage of unique trigrams from all the bigrams in the corpus.' .format(ngram(corpus, 2), ngram(corpus, 3)))","def analyse(self):\n logging.info(\"transferring text to CorpusCook...\")\n\n paragraphs = self.text.split('\\n\\n')\n print(\"mean length of splitted lines\", (mean([len(p) for p in paragraphs])))\n\n # If TIKA resolved '\\n'\n if (mean([len(p) for p in paragraphs])) > 80:\n paragraphs = [re.sub(r\"- *\\n\", '', p) for p in paragraphs]\n paragraphs = [p.replace('\\n', \" \") for p in paragraphs]\n paragraphs = [p.replace(';', \" \") for p in paragraphs]\n joiner = \" \"\n else:\n # If TIKA did not\n joiner = \" \"\n\n processed_text = joiner.join([p\n for p in paragraphs\n if\n p and\n ks_2samp(self.normal_data, list(p)).pvalue > self.threshold\n ]\n )\n\n return processed_text.strip()[:self.length_limit]","def _count_word_frequency(self, data):\n _dict = {}\n for _docs in data:\n for _word in _docs:\n if _word in _dict:\n _dict[_word] += 1\n else:\n _dict[_word] = 1\n return _dict","def train():\n\tA = collections.defaultdict(dict)\n\tB = collections.defaultdict(dict)\n\tpos_list = []\n\tword_list = []\n\tstr_buf = []\n\n\n\t# read each line and count A and B\n\tfor line in sys.stdin:\n\t\tline = line.split()\n\t\t# print(line)\n\t\tif len(line) == 3:\n\t\t\tstr_buf.append((str(line[0]), str(line[1])))\n\t\t\tword_list.append(str(line[0]))\n\t\t\tpos_list.append(str(line[1]))\n\n\t\telse:\n\t\t\t# if come to the end of a sentence\n\t\t\tif len(str_buf) != 0:\n\t\t\t\tstr_buf = [('<s>','BOS')] + str_buf + [('</s>', 'EOS')]\n\t\t\t\tword_list += ['<s>', '</s>']\n\t\t\t\tpos_list += ['BOS', 'EOS']\n\n\t\t\t\tfor i, s in enumerate(str_buf):\n\t\t\t\t\tif s[0] in B[s[1]]:\n\t\t\t\t\t\tB[s[1]][s[0]] += 1\n\t\t\t\t\telse:\n\t\t\t\t\t\tB[s[1]][s[0]] = 1\n\n\t\t\t\t\tif s[0] != '</s>':\n\t\t\t\t\t\t# print('strbuf[i]:',str_buf[i], 's[1]', s[1])\n\t\t\t\t\t\tif str_buf[i+1][1] in A[s[1]]:\n\t\t\t\t\t\t\tA[s[1]][str_buf[i+1][1]] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tA[s[1]][str_buf[i+1][1]] = 1\n\n\t\t\t\tstr_buf = []\n\n\t# get unique POS list and word list\n\tpos_list_uniq = list(set(pos_list))\n\tword_list_uniq = list(set(word_list))\n\n\n\t# assume <UNK>, smoothing, normalize\n\tB_sm = collections.defaultdict(dict)\n\tA_sm = A.copy()\n\n\t# assume words apeear less than 2 times as <UNK>\n\tword_count = collections.Counter(word_list)\n\tfor pos in B:\n\t\tfor word in B[pos]:\n\t\t\tif word_count[word] > 1:\n\t\t\t\tB_sm[pos][word] = B[pos][word]\n\n\t\t\telse: # add <UNK> to B_sm\n\t\t\t\tword_list_uniq.remove(word)\n\t\t\t\tif '<UNK>' in B_sm[pos]:\n\t\t\t\t\tB_sm[pos]['<UNK>'] += 1\n\t\t\t\telse:\n\t\t\t\t\tB_sm[pos]['<UNK>'] = 1\n\n\tword_list_uniq += ['<UNK>']\n\n\t# add 1 smoothing\n\tfor pos in pos_list_uniq:\n\t\tfor word in word_list_uniq:\n\t\t\tif word in B_sm[pos]:\n\t\t\t\tB_sm[pos][word] += 1\n\t\t\telse:\n\t\t\t\tB_sm[pos][word] = 1\n\n\tfor prev in pos_list_uniq:\n\t\tfor next in pos_list_uniq:\n\t\t\tif next in A_sm[prev]:\n\t\t\t\tA_sm[prev][next] += 1\n\t\t\telse:\n\t\t\t\tA_sm[prev][next] = 1\n\n\t# delete instances like A[VB][BOS], A[EOS][VB],\n\t# B[VB]['</s>'], B[EOS]['Jack']\n\n\tfor pos in B_sm:\n\t\tfor word in B_sm[pos]:\n\t\t\tif (pos == 'BOS' and word != '<s>') or \\\n\t\t\t(pos == 'EOS' and word != '</s>') or \\\n\t\t\t(word == '<s>' and pos != 'BOS') or \\\n\t\t\t(word == '</s>' and pos != 'EOS'):\n\t\t\t\tB_sm[pos][word] = 0\n\n\tfor prev in A_sm:\n\t\tfor next in A_sm[prev]:\n\t\t\tif prev == 'EOS' or next == 'BOS':\n\t\t\t\tA_sm[prev][next] = 0\n\n\t# normalize\n\tfor pos in B_sm:\n\t\ts = sum(B_sm[pos].values())\n\t\tfor word in B_sm[pos]:\n\t\t\tif B_sm[pos][word] != 0:\n\t\t\t\tB_sm[pos][word] /= s\n\n\tfor prev in A_sm:\n\t\ts = sum(A_sm[prev].values())\n\t\tfor next in A_sm[prev]:\n\t\t\tif A_sm[prev][next] != 0:\n\t\t\t\tA_sm[prev][next] /= s\n\n\treturn A_sm, B_sm, word_list_uniq","def num_syllables(self, word):\n # TODO: provide an implementation!\n word = word.lower()\n D = self._pronunciations\n #D = nltk.corpus.cmudict.dict()\n if(word not in D.keys()):\n #print word not in CMUDictionary\n return 1\n\n #count stores no of syllables for each pronunciation of the word\n count = []\n\n #for each pronunciation\n for x in D[word]:\n n = 0\n #for each syllable\n for y in x:\n #if vowel sound\n if y[-1].isdigit():\n n = n + 1\n count.append(n)\n # return the pronunciation having least syllables\n return min(count)\n #return min([len([y for y in x if y[-1].isdigit()]) for x in D[word.lower()]])","def get_word_frequency():\n counter = Counter()\n with open('resource/word-count.txt', encoding=\"utf8\") as f:\n for line in f.readlines():\n try:\n word, count = line.split(':')\n if (word == \"RT\"):\n continue\n count = int(count)\n counter[word] += count\n except Exception as e:\n continue\n return counter","def analyze(self, text):\n\n # TODO\n # tokens = tokenizer.tokenize(tweet)\n tokenizer = nltk.tokenize.TweetTokenizer()\n tokens = tokenizer.tokenize(text)\n score = 0\n\n for word in tokens:\n # iterate over tokens#str.lower\n\n if word.lower() in self.positives:\n score = score+1\n\n elif word.lower() in self.negatives:\n score = score-1\n\n else:\n continue\n return score","def process_text(self, text):\n\n flags = (re.UNICODE if sys.version < '3' and type(text) is unicode # noqa: F821\n else 0)\n pattern = r\"\\w[\\w']*\" if self.min_word_length <= 1 else r\"\\w[\\w']+\"\n regexp = self.regexp if self.regexp is not None else pattern\n\n words = re.findall(regexp, text, flags)\n # remove 's\n words = [word[:-2] if word.lower().endswith(\"'s\") else word\n for word in words]\n # remove numbers\n if not self.include_numbers:\n words = [word for word in words if not word.isdigit()]\n # remove short words\n if self.min_word_length:\n words = [word for word in words if len(word) >= self.min_word_length]\n\n stopwords = set([i.lower() for i in self.stopwords])\n if self.collocations:\n word_counts = unigrams_and_bigrams(words, stopwords, self.normalize_plurals, self.collocation_threshold)\n else:\n # remove stopwords\n words = [word for word in words if word.lower() not in stopwords]\n word_counts, _ = process_tokens(words, self.normalize_plurals)\n\n return word_counts","def all_categories_for_phrase(db, phrase, access_codes):\n ratings = [0, 0, 0]\n for access_code in access_codes:\n category_index = annotator_category_for_phrase(db, phrase, access_code)\n ratings[category_index] += 1\n return ratings","def sentiment_analysis(self):\n train_pos = pd.read_csv(\"data/train_Arabic_tweets_positive_20190413.tsv\", sep='\\t', names=[\"label\", \"tweet\"])\n train_neg = pd.read_csv(\"data/train_Arabic_tweets_negative_20190413.tsv\", sep='\\t', names=[\"label\", \"tweet\"])\n train = pd.concat([train_pos, train_neg])\n train.tweet = train.tweet.apply(self.preprocessor).apply(tokenization).apply(lambda x: x.tokens[0])\n le = LabelEncoder()\n le.fit(train.label)\n train.label = le.transform(train.label)\n\n sentence_inds, vocab, self.num_tokens, word_index, index_word = helper.encode_tokens(train.tweet.values)\n\n\n self.embeddings_matrix = helper.load_embedding_matrix(self.num_tokens, self.embedding_size, \n word_index, self.embeddings_index)\n\n\n train_padded = pad_sequences(sentence_inds, padding=\"post\", truncating=\"post\", maxlen=100)\n\n self.X_train, self.X_valid, self.y_train, self.y_valid = train_test_split(train_padded, train.label.values, test_size=0.5,random_state=0, stratify=train.label.values)\n\n model = self.train_model()\n y_pred = model.predict(self.X_valid)\n return (np.argmax(y_pred, axis=1) == self.y_valid).sum() / self.y_valid.shape[0]","def get_data(articles): # Here, the articles will be very long strings\r\n vdictionary = {} # dictionary for tokens that are found in dictionary\r\n _odata = [0] * 12 # list collecting everything except date; last number of words=index:0\r\n word_length = 0 # initializing the value of word length; will be updated via loop\r\n tokens = re.findall('\\w+', articles) # Note that \\w+ splits hyphenated words\r\n for token in tokens: # Goes through generated tokens from articles\r\n if (not token.isdigit()) and (len(token) > 1) and (token in lm_dictionary.keys()): # conditions for checking if token is in dictionary\r\n _odata[1] += 1 # updating word count \r\n word_length += len(token) # updating word length\r\n if token not in vdictionary: # initial statement regarding steps for handling tokens not in the dictionary\r\n vdictionary[token] = 1 # count of tokens in text that show up in dictionary\r\n \r\n####### Keeping Track of Categorical Token Counts (Nonzero entry=True) also checks if word is stop word\r\n if lm_dictionary[token].positive and not lm_dictionary[token].stopword: _odata[2] += 1\r\n if lm_dictionary[token].negative and not lm_dictionary[token].stopword: _odata[3] += 1\r\n if lm_dictionary[token].uncertainty and not lm_dictionary[token].stopword: _odata[4] += 1\r\n if lm_dictionary[token].litigious and not lm_dictionary[token].stopword: _odata[5] += 1\r\n if lm_dictionary[token].weak_modal and not lm_dictionary[token].stopword: _odata[6] += 1\r\n if lm_dictionary[token].moderate_modal and not lm_dictionary[token].stopword: _odata[7] += 1\r\n if lm_dictionary[token].strong_modal and not lm_dictionary[token].stopword: _odata[8] += 1\r\n if lm_dictionary[token].constraining and not lm_dictionary[token].stopword: _odata[9] += 1\r\n #total_syllables += lm_dictionary[token].syllables # interesting parameter to measure\r\n\r\n #_odata[12] = len(re.findall('[0-9]', doc))\r\n # drop punctuation within numbers for number count\r\n articles = re.sub('(?!=[0-9])(\\.|,)(?=[0-9])', '', articles)\r\n articles = articles.translate(str.maketrans(string.punctuation, \" \" * len(string.punctuation)))\r\n #_odata[13] = len(re.findall(r'\\b[-+\\(]?[$€£]?[-+(]?\\d+\\)?\\b', doc))\r\n # _odata[14] = total_syllables / _odata[2]\r\n #print(_odata[1])\r\n _odata[10] = word_length / _odata[1] # computing average word length\r\n _odata[11] = len(vdictionary) # total vocab count\r\n \r\n # Convert counts to %\r\n for i in range(2, 9 + 1): # specifying range of percentages\r\n try:\r\n _odata[i] = (_odata[i] / _odata[1]) * 100 # updating count to percent\r\n except:\r\n print(\"zero denominator\")\r\n # Vocabulary\r\n \r\n return _odata # returning the data\r","def computeWordsFrequencies(self):\n token_stream = self._tokenize(self.readable)\n token_map = self._countTokens(token_stream)\n # print token_map.items()\n return sorted(token_map.items(), key = lambda x : x[1], reverse = True)","def analyze(self, text):\n\n sent = 0\n for word in text.split():\n # check each word in tweet\n if word.strip(\":, \").lower() in self.posWords:\n sent += 1\n elif word.strip(\":, \").lower() in self.negWords:\n sent -= 1\n\n return sent","def analyze_emoji_sentimens(text):\n sum = 0.0\n count = 0\n for character in list(text):\n value = index.get(character, None)\n if value != None:\n sum += value\n count += 1\n if count == 0:\n return 0.0\n\n return sum/count","def sentiment_analyzer(text):\n\n\tlower_text = text.lower()\n\t\t\n\thashtag_scaling = 0.3\n\texclamation_scaling = 0.5\n\tuppercase_scaling = 0.2\n\n\n\tsent_index = 0\n\n\tfor x in range(len(positive_words)):\n\t\tsent_index += lower_text.count(positive_words[x])\n\tfor x in range(len(negative_words)):\n\t\tsent_index -= lower_text.count(negative_words[x])\n\tif '!' in text:\n\t\tsent_index *= exclamation_scaling * lower_text.count('!') + 1\n\tif '#' in text:\n\t\tsent_index *= hashtag_scaling * lower_text.count('#') + 1\n\tsent_index *= uppercase_scaling * sum(1 for c in text if c.isupper())\n\t\t\n\treturn sent_index","def get_corpus_counts(x,y,label):\n raise NotImplementedError","def read_gulordava_corpus(corpus_dir: str) -> dict:\n def _read_file(path: str) -> List[str]:\n with open(path, \"r\") as f:\n return f.readlines()\n\n sentences = _read_file(f\"{corpus_dir}/generated.text\")\n sentence_info = _read_file(f\"{corpus_dir}/generated.tab\")[1:] # Skip header line\n labelled_corpus = {}\n\n for i, sentence in enumerate(sentences):\n right_info, wrong_info = sentence_info[2*i], sentence_info[2*i+1]\n\n # Parse lines\n right_info, wrong_info = right_info.split(\"\\t\"), wrong_info.split(\"\\t\")\n constr_id, sent_id, correct_number, right_form, class_, type_ = right_info[1:7]\n len_context, len_prefix, sent = right_info[11:14]\n constr_id_wrong, sent_id_wrong, _, wrong_form, class_wrong, type_wrong = wrong_info[1:7]\n sent_wrong = wrong_info[13]\n\n assert class_ == \"correct\" and class_wrong == \"wrong\"\n assert constr_id == constr_id_wrong and sent_id == sent_id_wrong and sent == sent_wrong and type_ == type_wrong\n\n len_prefix, len_context = int(len_prefix), int(len_context)\n subj_pos = len_prefix - len_context\n verb_pos = len_prefix\n sentence = sent.split()\n\n misc_info = {\n \"raw\": sent,\n \"subj_pos\": subj_pos,\n \"verb_pos\": verb_pos,\n \"right_form\": right_form,\n \"wrong_form\": wrong_form,\n \"correct_number\": correct_number,\n \"sent_id\": sent_id,\n \"constr_id\": constr_id,\n \"type\": type_\n }\n\n labelled_sentence = {\n \"sen\": sentence, \"labels\": [0 if correct_number == \"sing\" else 1] * len(sentence), **misc_info\n }\n labelled_corpus[i] = labelled_sentence\n\n return labelled_corpus","def word_count():\n word_counter = Counter()\n\n # read files and count words\n for file_path in Path(INPUTS_PATH).rglob(\"*\"):\n if file_path.is_file():\n print(f\"Processing input file: {file_path.as_posix()}\")\n word_counter += Counter(file_path.read_text().split())\n\n # write the result to OUTPUTS_PATH\n output_file = Path(OUTPUTS_PATH) / \"output.txt\"\n with output_file.open(\"w\") as f:\n for word, count in word_counter.most_common():\n f.write(f\"{word}: {count}\\n\")\n print(f\"Generated output file: {output_file.as_posix()}\")","def load_input(path):\n counts = defaultdict(int)\n if not os.path.exists(mode+'indices.p'):\n root = '/'.join(path.split('/')[0:-1])\n all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\n else:\n all_paths = [path]\n \n for path in all_paths:\n print(path)\n with open(path) as f:\n if mode == 'word':\n words = tokenize(f.read())\n else:\n words = f.read()\n\n for word in words:\n counts[word] += 1 \n\n words = [x for x in words if len(x) > 0]\n return words, counts","def analyze_reviews(reviews):\n\n good_reviews=reviews[reviews['rs_review_movie_score']>=9]\n bad_reviews=reviews[reviews['rs_review_movie_score']<=2]\n\n print 'len(good_reviews)=%s' % len(good_reviews)\n print 'len(bad_reviews)=%s' % len(bad_reviews)\n\n m = re.compile('\\d')\n\n english_stop_words=stopwords.words('english')\n\n\n def tokenize(text):\n tokens=nltk.word_tokenize(text)\n # strip out trailing puncutation\n tokens = [ token[:-1] if token[-1] in ['.',',','!','?'] else token for token in tokens]\n\n # lower case\n tokens = [token.lower() for token in tokens]\n\n # Take only relativly long characters\n tokens = [token for token in tokens if len(token)>=3]\n\n # remove words with numbers/digits\n tokens = [token for token in tokens if m.search(token) is None]\n\n # Remove stop words: http://nltk.googlecode.com/svn/trunk/doc/book/ch02.html\n tokens = [token for token in tokens if token not in english_stop_words]\n return tokens\n\n good_tokens_list = []\n for i,review in good_reviews.iterrows():\n text=review['rs_review_text']\n good_tokens_list.append(tokenize(text))\n\n bad_tokens_list = []\n for i,review in bad_reviews.iterrows():\n text=review['rs_review_text']\n bad_tokens_list.append(tokenize(text))\n\n all_words=Counter()\n for tokens in good_tokens_list + bad_tokens_list:\n for token in tokens:\n all_words[token]+=1\n\n most_common=all_words.most_common(2000)\n most_common=zip(*most_common)[0]\n\n print 'most_common_words = ',most_common[-20:]\n\n def document_features(tokens):\n return {word:word in tokens for word in most_common}\n\n good_set=[(document_features(tokens), 'pos') for tokens in good_tokens_list]\n bad_set=[(document_features(tokens), 'neg') for tokens in bad_tokens_list]\n\n train_set = good_set + bad_set\n random.shuffle(train_set) # dunno if this is necessary\n\n classifier = nltk.NaiveBayesClassifier.train(train_set)\n\n print 'accuracy',nltk.classify.accuracy(classifier, train_set)\n\n classifier.show_most_informative_features(300)\n\n return classifier","def structure_anslysis(text, display = None):\n st.write('Text Size Exceeded! Truncating...')\n doc = nlp(text[:100000])\n pos_freq = pos_tag_counts(doc)\n ent_freq = entity_counts(doc)\n \n fig, axs = plt.subplots(1, 2, figsize = (15, 6))\n \n sns.barplot(list(pos_freq.keys()), list(pos_freq.values()), color='#e84118', ax = axs[0])\n axs[0].set_title('POS COUNTS')\n axs[0].set_xticklabels(labels = list(pos_freq.keys()), rotation = 90)\n \n sns.barplot(list(ent_freq.keys()), list(ent_freq.values()), color='#273c75', ax = axs[1])\n axs[1].set_title('ENTITY COUNTS')\n axs[1].set_xticklabels(labels = list(ent_freq.keys()), rotation = 90) \n \n plt.show()\n \n if display:\n spacy_streamlit.visualize_ner(doc, labels = nlp.get_pipe('ner').labels)\n \n \n return pos_freq, ent_freq","def add_unique_word_count(self):\n call_count = lambda letter_: self._count_unique_words(letter_)\n self.dataframe['unique_words'] = self.dataframe['letter'].map(call_count)","def measure(colloc_tag, colloc_count, n1grams, unigrams, n):\r\n collocation_words, collocation_tags = colloc_tag.split('/')\r\n collocation_words = collocation_words.split(' ')\r\n collocation_tags = collocation_tags.split(' ')\r\n pattern_words = ' '.join(collocation_words[:-1])\r\n pattern_tags = ' '.join(collocation_tags[:-1])\r\n\r\n pattern = pattern_words + '/' + pattern_tags\r\n last_word = collocation_words[-1] + '/' + collocation_tags[-1]\r\n c_pattern = int(n1grams[pattern])\r\n c_lw = int(unigrams[last_word])\r\n colloc_count = int(colloc_count)\r\n\r\n tsc = t_score(colloc_count, c_pattern, c_lw, n)\r\n pmisc = pmi(colloc_count, c_pattern, c_lw, n)\r\n logdsc = logDice(colloc_count, c_pattern, c_lw)\r\n return logdsc, pmisc, tsc","def gather_counts(directory):\n counts_un = defaultdict(int)\n counts_bi = defaultdict(int)\n counts_tri = defaultdict(int)\n prev_prev = \"<s>\"\n prev = \"<s>\"\n for filename in os.listdir(f\"./{directory}\"):\n if \".DS_Store\" in filename:\n continue\n with open(f\"./{directory}/{filename}\", \"r\") as f:\n for line in f:\n line = line.strip()\n if len(line) == 0:\n continue\n counts_un[line+\"\\n\"] += 1\n counts_bi[prev+\"\\n\"+line+\"\\n\"] += 1\n counts_tri[prev_prev+\"\\n\"+prev+\"\\n\"+line+\"\\n\"] += 1\n prev_prev = prev\n prev = line\n counts_un[\"</s>\\n\"] += 2\n counts_bi[\"</s>\\n</s>\\n\"] += 1\n counts_bi[prev+\"\\n\"+\"</s>\\n\"] += 1\n counts_tri[prev_prev+\"\\n\"+prev+\"\\n\" + \"</s>\\n\"] += 1\n counts_tri[prev+\"\\n</s>\\n</s>\\n\"] += 1\n return counts_un, counts_bi, counts_tri","def preprocessing(raw_text_df):\r\n \r\n stemmer = nltk.stem.porter.PorterStemmer()\r\n tokenizer = RegexpTokenizer(r'\\w+')\r\n # iterate over all lines for preprocessing\r\n for index, line in enumerate(raw_text_df):\r\n \r\n # if there is mention of stars from 1-5, change the integer into\r\n # text and combine the number and the word \"star\" to make a new word\r\n # example: \"I give this product 1 star\" is now \"I give this product onestar\"\r\n # why? numbers are removed as part of preprocessing\r\n if \"1 star\" in line:\r\n line = line.replace(\"1 star\", \"onestar\")\r\n if \"1 stars\" in line:\r\n line = line.replace(\"1 stars\", \"onestar\")\r\n if \"2 star\" in line:\r\n line = line.replace(\"2 star\", \"twostars\")\r\n if \"2 stars\" in line:\r\n line = line.replace(\"2 stars\", \"twostars\")\r\n if \"3 star\" in line:\r\n line = line.replace(\"3 star\", \"threestars\")\r\n if \"3 stars\" in line:\r\n line = line.replace(\"3 stars\", \"threestars\")\r\n if \"4 star\" in line:\r\n line = line.replace(\"4 star\", \"fourstars\")\r\n if \"4 stars\" in line:\r\n line = line.replace(\"4 stars\", \"fourstars\")\r\n if \"5 star\" in line:\r\n line = line.replace(\"5 star\", \"fivestars\")\r\n if \"5 stars\" in line:\r\n line = line.replace(\"5 stars\", \"fivestars\")\r\n \r\n # tokenize lines\r\n tokens = re.split('(\\d+)',line)\r\n # remove numbers\r\n no_digits = [w for w in tokens if not w.isdigit()]\r\n # join tokens\r\n joined_text = \" \".join(no_digits)\r\n # re tokenize\r\n tokens = tokenizer.tokenize(joined_text)\r\n # make tokens lowercase\r\n lower_tokens = [w.lower() for w in tokens if type(w) == str] \r\n # remove stopwords\r\n stopped_tokens = [w for w in lower_tokens if not w in stopwords.words('english')]\r\n # stem words\r\n clean_tokens = [stemmer.stem(w) for w in stopped_tokens]\r\n # join text\r\n joined_text = \" \".join(clean_tokens)\r\n # replace line with preprocessed line\r\n raw_text_df[index] = joined_text\r\n print(index)","def calculate_word_counts(text : Text)->Counter:\n return Counter(tokenized_text(text))","def get_all_words(annotation_files):\n all_words = np.array([])\n for annotation_file in annotation_files:\n annotations = []\n with open(annotation_file, 'r', encoding='utf-8') as f:\n lines = f.readlines()\n for line in lines:\n line = line.strip().rstrip('\\n').lstrip('\\ufeff').strip().split(',', maxsplit=8)\n if str(line[-1]).strip() != \"\" and str(line[-1]).strip() is not None:\n annotations.append(str(line[-1]).strip())\n annotations = np.array(annotations)\n all_words = np.concatenate((all_words, annotations), axis=0)\n unique_words = list(set(all_words))\n print(\"Get_All_Words::All words num / Unique words num is {0}/{1}\".format(len(all_words), len(unique_words)))\n return all_words, unique_words","def convert_word_to_count(counter={}, doc=[]):\n for sentence in doc:\n for word in sentence.split():\n if word not in counter:\n counter[word] = 1\n else:\n counter[word] += 1\n return counter","def wordFreq(parseThis):\n \n freq = {}\n nono = ('\"', \"'\", '%', '$', '!', '.', '?', '-', ','\n , '\\n', '\\t', '\\r', ':', ';')\n\n for c in nono:\n parseThis = parseThis.replace(c, \" \")\n \n words = parseThis.split()\n \n for word in words:\n temp = word.lower()\n freq[temp] = freq.get(temp, 0) + 1\n\n return freq","def basic_statistics_of_email(data):\n word_counts = []\n character_count = 0\n\n for ind, row in data.iterrows():\n tokenizer = RegexpTokenizer(r'\\w+')\n real_words = tokenizer.tokenize(row[\"RawText\"].lower())\n\n character_count += sum(map(len, real_words))\n word_counts.append(len(real_words))\n\n return character_count, pd.Series(word_counts)","def train_ngrams(dataset):\n trigram_counts = dict()\n bigram_counts = dict()\n unigram_counts = dict()\n token_count = 0\n\n ### YOUR CODE HERE\n def enterDic(phrase, dict):\n if phrase in dict:\n dict[phrase] += 1\n else:\n dict[phrase] = 1\n\n unigram_counts[word_to_num['UUUNKKK']] = 0\n\n for sentence in dataset:\n enterDic(sentence[1], unigram_counts) # count number of start of sentences\n enterDic((sentence[0], sentence[1]), bigram_counts) # count number of start of sentences\n token_count += 2\n for i in range(2, len(sentence)):\n token_count += 1\n enterDic(sentence[i], unigram_counts)\n enterDic((sentence[i - 1], sentence[i]), bigram_counts)\n enterDic((sentence[i - 2], sentence[i - 1], sentence[i]), trigram_counts)\n ### END YOUR CODE\n return trigram_counts, bigram_counts, unigram_counts, token_count","def train(self, corpus): \n for sentence in corpus.corpus: # iterate over sentences in the corpus\n for token in sentence: # iterate over datums in the sentence\n self.unigrams[token] += 1\n self.total += 1\n V = len(self.unigrams) # vocabulary size \n for ug,count in self.unigrams.iteritems():\n \tself.f1[ug] = math.log10(count+1) - math.log10(self.total + V)","def get_num_words_spoken_by_character_per_episode(content):\n content = list(csv.reader(content.splitlines(), delimiter=','))\n characters = [name[2] for name in content]\n characters = list(dict.fromkeys(characters))\n del characters[0]\n res = defaultdict()\n for character in characters:\n episode = 1\n dic = {}\n count = 0\n for row in content: \n if row[2] == character:\n if str(episode) == row[1]:\n count += len(row[3].split())\n else:\n dic[str(episode)] = count\n episode = int(row[1])\n count = len(row[3].split())\n if '13' not in dic.keys():\n dic['13'] = count \n dic = Counter(dic)\n res[character] = dic\n return res"],"string":"[\n \"def load_word_counts(filename):\\n raw_rows = csv_rows(filename)\\n word_counts = defaultdict(lambda: 0)\\n\\n for line_number, raw_row in enumerate(raw_rows, 2):\\n count = int(raw_row[\\\"count\\\"])\\n ipa = raw_row[\\\"IPA\\\"]\\n if '*' in ipa:\\n continue\\n\\n # Fixes random badness.. hopefully doesn't hide anything?\\n mod_ipa = ipa.replace('(', '').replace(')', '')\\n\\n # Work around a passage with an error in it:\\n gloss = raw_row[\\\"Gloss\\\"] or raw_row[\\\"Text\\\"]\\n\\n category = raw_row[\\\"Category\\\"]\\n\\n skipword_characters = {'?'}\\n try:\\n for i, g in izip(mod_ipa.split('/'), gloss.split('/')):\\n word = make_word(i, g, category)\\n word_counts[word] += count\\n except WordParseError as e:\\n print (u\\\"Error on line %d: %s [%s || %s]\\\" %\\n (line_number, repr(e), ipa, gloss)).encode('utf-8')\\n except IndexError as e:\\n unknown_index = e.args[0]\\n if unknown_index in skipword_characters:\\n print (u\\\"Bad char on line %d: %s [%s || %s]\\\" %\\n (line_number, repr(e), ipa, gloss)).encode('utf-8')\\n else:\\n print \\\"FATAL ERROR ON LINE %d\\\" % line_number\\n raise\\n except:\\n print \\\"FATAL ERROR ON LINE %d\\\" % line_number\\n raise\\n return word_counts\",\n \"def total_syllables(target_text):\\n\\n splited_text = target_text.split()\\n count = 0\\n for word in splited_text:\\n count = count + word_syllables(word)\\n return count\",\n \"def get_analyze_per_file(self):\\n \\\"\\\"\\\"Exclude tags, exclude binary (img), count words without non literal characters and digits\\\"\\\"\\\"\\n filename = f'{self.path}/{self.filename}'\\n file = open(filename, 'r', encoding='utf-8')\\n df_tmp = pd.DataFrame(columns=['word', 'cnt', 'word_low'])\\n w_cnt = 0\\n word_counter = {}\\n data = file.read()\\n head, sep, tail = data.partition('<binary')\\n head = re.sub('\\\\\\\\s\\\\\\\\s*', ' ', (re.sub('\\\\\\\\W|\\\\\\\\d', ' ', re.sub('<.*?>', '', head))))\\n word_list = head.split()\\n for word in word_list:\\n\\n if word not in word_counter:\\n word_counter[word] = 1\\n else:\\n word_counter[word] = word_counter[word] + 1\\n w_cnt += 1\\n\\n for word, occurance in word_counter.items():\\n df_tmp = df_tmp.append({'word': '{:15}'.format(word), 'cnt': '{:3}'.format(occurance),\\n 'word_low': '{:15}'.format(word).lower()}, ignore_index=True)\\n df_tmp = df_tmp.sort_values(by='word_low')\\n df_tmp.loc[(df_tmp.word != df_tmp.word_low), 'word'] = df_tmp.cnt\\n df_tmp.loc[(df_tmp.word == df_tmp.cnt), 'cnt'] = 0\\n df_tmp.loc[(df_tmp.word == df_tmp.word_low), 'word'] = 0\\n df_tmp['word'] = df_tmp.word.astype(int)\\n df_tmp['cnt'] = df_tmp.cnt.astype(int)\\n df_tmp = df_tmp.groupby(['word_low'])['cnt', 'word'].sum().reset_index()\\n conn = sqlite3.connect('for_python_ht.db')\\n try:\\n try:\\n sqlite_for_ht.CreateTableSingle.delete_table(f_3, self.filename)\\n print(datetime.now(), '-', self.filename, 'Table deleted at the start point')\\n except Exception:\\n print(datetime.now(), '-', 'Something went wrong')\\n traceback.print_exc()\\n df_tmp.to_sql(name=self.filename, con=conn, index=False)\\n print(datetime.now(), '-', self.filename, 'Table created and filled with data')\\n except Exception:\\n print(datetime.now(), '-', 'file with name {} already exists'.format(self.filename))\\n traceback.print_exc()\\n print(datetime.now(), '-', 'word analyse for', self.filename, 'done')\\n sqlite_for_ht.HandleTemp.update_table(f_2, 'status', 'Done', self.filename)\\n return None\",\n \"def process():\\n words = read_csv('american-words.80', header=None)\\n def get_value(word):\\n \\\"\\\"\\\"\\n A sub-process run on each word. It gets the value of each letter, and add up the values for the whole word.\\n \\\"\\\"\\\"\\n letters = 'abcdefghijklmnopqrstuvwxyz'\\n sum = 0\\n for letter in word:\\n letter_value = letters.find(letter)\\n if letter_value == -1:\\n letter_value = 0\\n sum += letter_value\\n return sum\\n words['values'] = words[0].apply(get_value)\\n # get those words whose values are 100\\n words = words[words['values'] == 100]\\n # get the length of these words and sort ascending\\n words['length'] = words[0].apply(len)\\n words = words.sort(columns='length')\\n return words[0].values\",\n \"def analyze_data(df, sentiment_col, tweet_col, path):\\n\\n # create empty dictionaries to store all encountered words and their frequencies\\n all_dict = {}\\n pos_dict = {}\\n neg_dict = {}\\n neu_dict = {}\\n # initialize counters to counter total number of tweets based on their emotion\\n pos_count = 0\\n neg_count = 0\\n neu_count = 0\\n\\n # iterate through each row of the df\\n for index, row in df.iterrows():\\n if row[sentiment_col] == \\\"positive\\\":\\n pos_count = iterate_words(\\n pos_count, row[tweet_col], all_dict, pos_dict)\\n\\n if row[sentiment_col] == \\\"negative\\\":\\n neg_count = iterate_words(\\n neg_count, row[tweet_col], all_dict, neg_dict)\\n\\n if row[sentiment_col] == \\\"neutral\\\":\\n neu_count = iterate_words(\\n neu_count, row[tweet_col], all_dict, neu_dict)\\n\\n # visualize statistics\\n visualize_stats(all_dict, 'all_plot.png', 'all_cloud.png',\\n 'Word frequency in all tweets', path)\\n visualize_stats(pos_dict, 'pos_plot.png', 'pos_cloud.png',\\n 'Word frequency in positive tweets', path)\\n visualize_stats(neg_dict, 'neg_plot.png', 'neg_cloud.png',\\n 'Word frequency in negative tweets', path)\\n visualize_stats(neu_dict, 'neu_plot.png', 'neu_cloud.png',\\n 'Word frequency in neutral tweets', path)\\n\\n # make plot for emotion frequency\\n emotions = ('Positive', 'Negative', 'Neutral')\\n freq = [pos_count, neg_count, neu_count]\\n sns.set_style(\\\"darkgrid\\\")\\n ax = plt.figure().gca()\\n ax.xaxis.grid(False)\\n ax.yaxis.set_major_locator(MaxNLocator(integer=True))\\n plt.bar(range(len(emotions)), freq, align='center',\\n color=['forestgreen', 'firebrick', 'goldenrod'])\\n plt.xticks(range(len(emotions)), emotions)\\n plt.title('Tweet frequency based on emotion')\\n plt.savefig(path + 'emotion_plot.png')\\n plt.close()\\n\\n # make pie for emotion frequency\\n sizes = [pos_count / len(df.index), neg_count /\\n len(df.index), neu_count / len(df.index)]\\n colors = ['forestgreen', 'firebrick', 'goldenrod']\\n plt.pie(sizes, labels=emotions, colors=colors,\\n autopct='%1.1f%%', startangle=140)\\n plt.title('Tweet frequency based on emotion')\\n plt.axis('equal')\\n plt.savefig(path + 'emotion_pie.png')\\n plt.close()\",\n \"def main ():\\n fio = FileIo(\\\"../input2.txt\\\")\\n text = fio.getInput()\\n p = re.compile(r'#?\\\\d[\\\\s\\\\.]?[\\\\s]?')\\n out = filter(None, p.split(text))\\n #print out[2]\\n #print len(out)\\n wc = 0\\n\\n for s in out:\\n text = nltk.word_tokenize(s)\\n wc += wordCount( text )\\n print wc\",\n \"def extract_syllable_features_from_txt():\\n input_files = sys.argv[1]\\n csv_name = sys.argv[2]\\n syllable_stats = pd.DataFrame(columns=SYLLABLE_COLUMNS)\\n re_word = re.compile(r'[\\\\w-]+')\\n i = 0\\n for filename in os.listdir(input_files):\\n if filename != '.DS_Store':\\n print(filename, i)\\n syllable_count = 0\\n for line in open(input_files+filename):\\n for word in re_word.findall(line):\\n syllable_count += estimate(word)\\n syllable_stats = syllable_stats.append({\\n TRANSCRIPT_ID: filename[:-4],\\n MEMORY_SYLLABLE_COUNT: syllable_count,\\n }, ignore_index=True)\\n i += 1\\n syllable_stats = syllable_stats.set_index(TRANSCRIPT_ID)\\n syllable_stats.to_csv(csv_name+'.csv')\",\n \"def count_words(filename):\",\n \"def analyze_embeddings(emb):\\n dic = {\\\"Hi\\\": 0, \\\"En\\\": 1, \\\"Ot\\\": 2}\\n count = [0, 0, 0, 0]\\n count_zero = [0, 0, 0, 0]\\n for i, j in zip(emb, corpus_trans):\\n for k, l in zip(i, j):\\n count[dic[l[1]]] += 1\\n if sum(k) == 0:\\n count_zero[dic[l[1]]] += 1\\n count[-1] = sum(count)\\n count_zero[-1] - sum(count_zero)\\n print(\\\"hi, en, ot, total\\\")\\n print(\\\"count: \\\", count)\\n print(\\\"zero count: \\\", count_zero)\",\n \"def updateWordCounts():\\n emaildata = loadEmailData()\\n englishwords = importDictionary()\\n countAllWords(emaildata, englishwords)\",\n \"def summarize_corpus():\\n\\t\\n\\t# get metadata\\n\\t#get_metadata.from_TEIP5(wdir, corpus_inpath, \\\"metadata\\\", md_mode)\\n\\t\\n\\t# visualize some metadata\\n\\t#visualize_metadata.describe_corpus(wdir, md_csv, \\\"author-continent\\\")\\n\\tvisualize_metadata.describe_corpus(wdir, md_csv, \\\"author-country\\\")\\n\\t#visualize_metadata.describe_corpus(wdir, md_csv, \\\"language\\\")\\n\\t#visualize_metadata.describe_corpus(wdir, md_csv, \\\"subgenre_hist\\\")\\n\\t#visualize_metadata.describe_corpus(wdir, md_csv, \\\"subgenre_x\\\")\\n\\tvisualize_metadata.plot_pie(wdir, md_csv, \\\"subgenre\\\")\\n\\n\\tvisualize_metadata.describe_corpus(wdir, md_csv, \\\"subgenre\\\")\\n\\t#visualize_metadata.describe_corpus(wdir, md_csv, \\\"gender\\\")\\n\\t\\n\\t# make some counts\\n\\tmd_table = pd.DataFrame.from_csv(os.path.join(wdir, md_csv), header=0)\\n\\tnum_texts = len(md_table)\\n\\t#num_language = len(md_table.groupby([\\\"language\\\"]))\\n\\t#num_continent = len(md_table.groupby([\\\"author-continent\\\"]))\\n\\t#num_countries = len(md_table.groupby([\\\"author-country\\\"]))\\n\\t#num_authors = len(md_table.groupby([\\\"author-name\\\"]))\\n\\tnum_authors = len(md_table.groupby([\\\"author-name\\\"]))\\n\\tnum_subgenre = len(md_table.groupby([\\\"subgenre\\\"]))\\n\\t#num_subgenre_x = len(md_table.groupby([\\\"subgenre_x\\\"]))\\n\\t#fr_subgenre_hist = md_table.groupby([\\\"subgenre_hist\\\"]).count()\\n\\t#num_historical = fr_subgenre_hist[\\\"idno\\\"][\\\"historical\\\"]\\n\\t#num_not_historical = fr_subgenre_hist[\\\"idno\\\"][\\\"not_historical\\\"]\\n\\t\\n\\t\\n\\td = {\\\"texts\\\":[num_texts], \\n\\t#\\\"languages\\\":[num_language],\\n\\t#\\\"continents\\\":[num_continent],\\n\\t#\\\"countries\\\":[num_countries],\\n\\t\\\"authors\\\":[num_authors],\\n\\t#\\\"subgenre_x\\\":[num_subgenre_x],\\n\\t\\\"subgenre\\\":[num_subgenre]}\\n\\t#\\\"num_historical\\\":[num_historical],\\n\\t#\\\"num_not_historical\\\":[num_not_historical]}\\n\\t\\n\\t\\n\\t\\n\\tcount_fr = pd.DataFrame(d)\\n\\tcount_fr.to_csv(os.path.join(wdir, \\\"corpus-description.csv\\\"), sep=\\\",\\\", header=True)\\n\\tprint(\\\"Done: summarize corpus\\\")\",\n \"def _count_vocab(self,raw_documents, fixed_vocab=False):\\n if fixed_vocab:\\n vocabulary = self.vocabulary_\\n else:\\n # Add a new value when a new vocabulary item is seen\\n vocabulary = defaultdict()\\n vocabulary.default_factory = vocabulary.__len__\\n\\n analyze = super().build_analyzer()\\n \\n j_indices = []\\n indptr = []\\n\\n values = array.array(str('f'))\\n indptr.append(0)\\n for doc in raw_documents:\\n #doc = tupla[0]\\n feature_counter = {}\\n #texttlist = doc.split(sep=\\\" \\\")\\n for feature in analyze(doc):#texttlist:\\n try:\\n \\n # Ignore out-of-vocabulary items for fixed_vocab=True\\n feature_idx = vocabulary[feature]\\n #print(feature_idx)\\n #fti_feature = calc_fti(feature,raw_documents)\\n \\n if feature_idx not in feature_counter:\\n feature_counter[feature_idx] = 1\\n else:\\n feature_counter[feature_idx] += 1\\n #print(feature_counter[feature_idx])\\n except KeyError:\\n # Ignore out-of-vocabulary items for fixed_vocab=True\\n continue\\n\\n\\n j_indices.extend(feature_counter.keys())\\n values.extend(feature_counter.values())\\n indptr.append(len(j_indices))\\n\\n if not fixed_vocab:\\n # disable defaultdict behaviour\\n vocabulary = dict(vocabulary)\\n if not vocabulary:\\n raise ValueError(\\\"empty vocabulary; perhaps the documents only\\\"\\n \\\" contain stop words\\\")\\n\\n if indptr[-1] > np.iinfo(np.int32).max: # = 2**31 - 1\\n if _IS_32BIT:\\n raise ValueError(('sparse CSR array has {} non-zero '\\n 'elements and requires 64 bit indexing, '\\n 'which is unsupported with 32 bit Python.')\\n .format(indptr[-1]))\\n indices_dtype = np.int64\\n\\n else:\\n indices_dtype = np.int32\\n \\n j_indices = np.asarray(j_indices, dtype=indices_dtype)\\n indptr = np.asarray(indptr, dtype=indices_dtype)\\n \\n #print (vocabulary)\\n X = sp.csr_matrix((values, j_indices, indptr),\\n shape=(len(indptr) - 1, len(vocabulary)),\\n dtype=np.float32)\\n X.sort_indices() \\n \\n self.vocabulary_calculated = vocabulary\\n\\n return vocabulary, X\",\n \"def analyzeFile(filename): \\n fileData = open(filename, encoding=\\\"utf-8\\\") # open the file\\n \\n counts = {}\\n\\n for line in fileData:\\t\\t # iterates over every line of the file\\n words = line.split() # turns each line into a list\\n for word in words: #iterates over the words in each line list\\n word = word.lower().strip(string.whitespace+string.punctuation)\\n if len(word) > 0: #make sure word is longer than 0 before adding it to the dictionary\\n counts[word] = counts.get(word, 0) + 1 #look up if the dictionary has that word and if not then it'll add that word with the value 0 associated with it and then add one to that, if it has seen it it'll add 1 to the value stored in the counts dictionary\\n #when it gets here for the first line it goes back up to the top and repeats for the 2nd line\\n mostCommonWord = [word]\\n leastCommonWord = [word]\\n shortestWord = [word]\\n longestWord = [word]\\n \\n for item in counts:\\n if counts[mostCommonWord[0]] < counts[item]:\\n mostCommonWord = [item]\\n elif counts[mostCommonWord[0]] == counts[item]:\\n mostCommonWord.append(item)\\n if counts[leastCommonWord[0]] > counts[item]:\\n leastCommonWord = [item]\\n elif counts[leastCommonWord[0]] == counts[item]:\\n leastCommonWord.append(item)\\n if len(shortestWord[0]) > len(item):\\n shortestWord = [item] \\n elif len((shortestWord[0])) == len(item):\\n shortestWord.append(item)\\n if len(longestWord[0]) < len(item):\\n longestWord = [item]\\n elif len(longestWord[0]) == len(item):\\n longestWord.append(item)\\n \\n return (mostCommonWord, leastCommonWord, shortestWord, longestWord)\",\n \"def extractWords(self, inputDataset):\\n reviewFile = open(inputDataset, \\\"r\\\", encoding=\\\"utf-8-sig\\\")\\n for record in reviewFile:\\n record = record.strip().split(\\\"\\\\t\\\") # tab-delimited .txt file\\n self.addUnigrams(int(record[0]), record[1])\\n reviewFile.close()\",\n \"def test_counts(self):\\n lines, words, chars = analyze_text(self.filename)\\n self.assertEqual(lines, 4)\\n self.assertEqual(words, 8)\\n self.assertEqual(chars, 36)\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = {} # might want to use defaultdict or Counter instead\\n self.bigramcounts = {} \\n self.trigramcounts = {} \\n\\n self.total = 2\\n ##Your code here\\n\\n for sentence in corpus:\\n temp_1 = get_ngrams(sentence,1)\\n temp_2 = get_ngrams(sentence,2)\\n temp_3 = get_ngrams(sentence,3)\\n for i in range(len(temp_1)):\\n if temp_1[i] in self.unigramcounts:\\n self.unigramcounts[temp_1[i]] += 1\\n else:\\n self.unigramcounts[temp_1[i]] = 1\\n self.total += 1\\n\\n for i in range(len(temp_2)):\\n if temp_2[i] in self.bigramcounts:\\n self.bigramcounts[temp_2[i]] += 1\\n else:\\n self.bigramcounts[temp_2[i]] = 1\\n\\n for i in range(len(temp_3)):\\n if temp_3[i] in self.trigramcounts:\\n self.trigramcounts[temp_3[i]] += 1\\n else:\\n self.trigramcounts[temp_3[i]] = 1\\n return\",\n \"def word_frequency():\\n\\n song = open(\\\"data/yellow_submarine.txt\\\")\\n d = dict()\\n for line in song:\\n line = line.strip()\\n line = line.lower()\\n punctuations = \\\"\\\"\\\"!()-[]{};:'\\\"\\\\,<>./?@#$%^&*_~\\\"\\\"\\\" # remove punctuation https://www.programiz.com/python-programming/examples/remove-punctuation\\n no_punct = \\\"\\\" # remove punctuation\\n for char in line: # remove punctuation\\n if char not in punctuations: # remove punctuation\\n no_punct = no_punct + char # remove punctuation\\n words = line.split(\\\" \\\")\\n for word in words:\\n d[word] = d.get(word, 0) + 1\\n return d\",\n \"def _count(self):\\n words = [word.lower() for word in self.corpus.words()]\\n bigrams_words = bigrams(words)\\n for bigram in bigrams_words:\\n self._bigrams[bigram] += 1\",\n \"def cleanCsv(): \\n\\n count_neutral = 0\\n count_sad = 0\\n count_angry = 0\\n count_happy = 0\\n\\n count_session_neutral = 0 \\n\\n for column_values in raw_data:\\n\\n if significant_data.fieldnames is None:\\n dh = dict((h, h) for h in raw_data.fieldnames)\\n significant_data.fieldnames = raw_data.fieldnames\\n significant_data.writerow(dh)\\n\\n if column_values['AOI[Sad_Right]Hit'] == '1':\\n significant_data.writerow(column_values)\\n count_sad = count_sad + 1\\n\\n if column_values['AOI[Neutral_Left]Hit'] == '1':\\n significant_data.writerow(column_values)\\n count_neutral = count_neutral + 1\\n\\n if column_values['AOI[Neutral_Left]Hit_0'] == '1':\\n significant_data.writerow(column_values)\\n count_neutral = count_neutral + 1\\n\\n if column_values['AOI[Neutral_Right]Hit'] == '1':\\n significant_data.writerow(column_values)\\n count_neutral = count_neutral + 1\\n\\n if column_values['AOI[Angry_Left]Hit'] == '1':\\n significant_data.writerow(column_values)\\n count_angry = count_angry + 1\\n\\n if column_values['AOI[Neutral_Right]Hit_0'] == '1':\\n significant_data.writerow(column_values)\\n count_neutral = count_neutral + 1\\n\\n if column_values['AOI[Happy_Right]Hit'] == '1':\\n significant_data.writerow(column_values)\\n count_happy = count_happy + 1\\n\\n if column_values['AOI[Neutral_Left]Hit_1'] == '1':\\n significant_data.writerow(column_values)\\n count_neutral = count_neutral + 1\\n\\n if column_values['AOI[Happy_Left]Hit'] == '1':\\n significant_data.writerow(column_values)\\n count_happy = count_happy + 1\\n\\n if column_values['AOI[Neutral_Right]Hit_1'] == '1':\\n significant_data.writerow(column_values)\\n count_neutral = count_neutral + 1\\n\\n if column_values['AOI[Sad_Left]Hit'] == '1':\\n significant_data.writerow(column_values)\\n count_sad = count_sad + 1\\n\\n if column_values['AOI[Neutral_Right]Hit_2'] == '1':\\n significant_data.writerow(column_values)\\n count_neutral = count_neutral + 1\\n\\n if column_values['AOI[Angry_Right]Hit'] == '1':\\n significant_data.writerow(column_values)\\n count_angry = count_angry + 1\\n\\n if column_values['AOI[Neutral_Left]Hit_2'] == '1':\\n significant_data.writerow(column_values)\\n count_neutral = count_neutral + 1\\n\\n return {\\n 'count_neutral': count_neutral,\\n 'count_sad': count_sad,\\n 'count_angry': count_angry,\\n 'count_happy': count_happy,\\n }\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = defaultdict(int)\\n self.bigramcounts = defaultdict(int)\\n self.trigramcounts = defaultdict(int)\\n\\n self.sentence_counts = 0\\n self.word_count = 0\\n\\n for line in corpus:\\n sequence = line\\n self.sentence_counts +=1\\n\\n unigrams = get_ngrams(sequence, n=1)\\n for gram in unigrams:\\n self.word_count += 1\\n self.unigramcounts[gram] +=1\\n\\n bigrams = get_ngrams(sequence, n=2)\\n for gram in bigrams:\\n self.bigramcounts[gram] +=1\\n\\n trigrams = get_ngrams(sequence, n=3)\\n for gram in trigrams:\\n self.trigramcounts[gram] +=1\\n\\n #self.unigramcounts[('START')] = self.sentence_counts *2\\n self.bigramcounts[('START', 'START')] = self.sentence_counts\\n\\n #return self\",\n \"def count_syllables(words):\\n\\n\\n count = 0\\n\\n for word in words:\\n word_count = count_syllables_in_word(word)\\n count = count + word_count\\n return count\",\n \"def word_frequency( tokenized, dic ):\\n print( 'computing word frequencies' )\\n start = time.time()\\n for i, text in enumerate( tokenized ):\\n for token in text:\\n if token not in dic:\\n dic[ token ] = 1\\n else:\\n dic[ token ] += 1\\n if i % 10000 == 0:\\n sys.stdout.write( '\\\\rprocessed : {}/{} reviews in {}s'.format( i, NO_REVIEWS, time.time() - start ) )\\n sys.stdout.write( '\\\\rprocessed : {}/{} reviews in {}s\\\\n'.format( i, NO_REVIEWS, time.time() - start ) )\",\n \"def count_same_words(cuisine_file, menu):\\n\\n cuisine_list = separate_words(cuisine_file)\\n \\n same_word_count = 0\\n \\n for i in cuisine_list:\\n for j in menu:\\n if i == j:\\n same_word_count += 1\\n \\n return same_word_count\",\n \"def count_words(self, contents):\\n wordCounts = {}\\n for i in self.ngramCounts:\\n if i == 0: # want the default to be the size of the corpus\\n total = 0\\n for line in contents:\\n words = line.split(\\\" \\\")\\n words = [ w.strip() for w in words if w] #remove nulls\\n for word in words:\\n if word:\\n total += 1\\n wordCounts[i] = defaultdict(lambda: total)\\n continue\\n else:\\n counts = defaultdict(lambda: 0)\\n for line in contents:\\n words = line.split(\\\" \\\")\\n words = [ w.strip() for w in words if w] #remove nulls\\n for k, word in enumerate(words): \\n if k < (i-1) or not word:\\n continue\\n key = \\\"\\\"\\n for j in range(k-i+1, k+1):\\n key += words[j] + \\\" \\\"\\n counts[key.strip()] += 1\\n wordCounts[i] = counts\\n return wordCounts\",\n \"def __parse_corpus(self, corpus):\\n corpus = self.__handle_corpus_unkwon_words(corpus)\\n start_token = ' '.join([NGramModel.START_SENTENCE_TOKEN]*(self.__n-1))\\n word_list = corpus.replace(NGramModel.START_SENTENCE_TOKEN, start_token).split()\\n \\n for n in range(1, self.__n+1): \\n self.__ngram_counts[n] = {}\\n for ngram, count in Counter(self.__generate_n_grams(word_list, n)).items():\\n self.__ngram_counts[n][' '.join(ngram)] = count\",\n \"def train(self, corpus):\\n for sentence in corpus.corpus:\\n for datum in sentence.data: \\n self.unigramCounts[datum.word] += 1\\n self.totalCount += 1\",\n \"def annotate_tsv_freq(in_tsv_gz,annotation_tsv):\\n sys.stderr.write(\\\"Reading TSV file ...\\\\n\\\")\\n nicollo = pd.read_csv(BOLLI, sep=\\\"\\\\t\\\")\\n nicollo = nicollo.iloc[:,[1,2,4,5,23]]\\n nicollo_counts = nicollo.groupby(['CHR','START'])['MT'].count()\\n nol_var = nicollo.drop(['WT','MT'], axis = 1) \\n nol_var = nol_var.set_index(['CHR', 'START'])\\n\\n #nicollo_counts = nicollo.groupby([\\\"CHR\\\",\\\"START\\\",\\\"WT\\\",\\\"MT\\\"]).size().reset_index(name=\\\"count\\\")\\n #nicollo_counts = nicollo_counts[[\\\"CHR\\\", \\\"START\\\",\\\"count\\\"]].set_index(['CHR','START'])\\n\\n mmrf = pd.read_csv('/ifs/res/leukgen/home/yellapav/MMRF/MMRF_CoMMpass_IA9_All_Canonical_Variants.txt', sep=\\\"\\\\t\\\")\\n mmrf=mmrf.iloc[:,[0,1,2,4,5,19,23]]\\n mmrf=mmrf.drop_duplicates()\\n\\n mmrfM=mmrf.groupby(['CHROM','POS'])['GEN[1].AR'].median()\\n mmrfC=mmrf.groupby(['CHROM','POS'])['GEN[1].AR'].count()\\n mmrfQ25=mmrf.groupby(['CHROM','POS'])['GEN[1].AR'].quantile(q=0.25)\\n mmrfQ75=mmrf.groupby(['CHROM','POS'])['GEN[1].AR'].quantile(q=0.75)\\n \\n\\n #anno_tsv = pd.read_csv(annotation_tsv, comment='#',sep=\\\"\\\\t\\\")\\n anno_tsv = pd.read_csv(annotation_tsv, comment='#',sep=\\\"\\\\t\\\", low_memory=False)\\n #anno_tsv[anno_tsv['FILTER'] == \\\"PASS\\\"]\\n counts_tsv=anno_tsv.groupby([\\\"CHR\\\",\\\"START\\\",\\\"REF\\\",\\\"ALT\\\"]).size().reset_index(name=\\\"count\\\")\\n counts_tsv=counts_tsv[[\\\"CHR\\\", \\\"START\\\",\\\"count\\\"]].set_index(['CHR','START'])\\n counts_median=anno_tsv.groupby(['CHR','START'])['TARGET_VAF'].median()\\n\\n\\n\\n inFile = gzip.open(in_tsv_gz,'r')\\n \\n sys.stderr.write(\\\"Annotating ...\\\\n\\\")\\n for record in inFile:\\n record=record.decode(\\\"utf-8\\\")\\n record=record.rstrip()\\n recArr=record.split(\\\"\\\\t\\\")\\n \\n cl = [] \\n freq = [] \\n medVAF = [] \\n Q25 = [] \\n Q75 = [] \\n positions = [] \\n normal = \\\"0\\\" \\n normalVAF = \\\"0\\\" \\n bolli_cl = [] \\n bolli_freq = [] \\n bolli_positions = [] \\n bolli_anno = [] \\n flag = 0\\n bolli_flag = 0\\n if record.startswith(\\\"#\\\"):\\n continue\\n\\n if recArr[0] == \\\"ID_VARIANT\\\":\\n cl = \\\"MMRF_Class\\\"\\n freq = \\\"MMRF_Frequency\\\"\\n medVAF = \\\"MMRF_VAF\\\"\\n Q25 = \\\"MMRF_Q25\\\"\\n Q75 = \\\"MMRF_Q75\\\"\\n positions = \\\"MMRF_Positions\\\"\\n normal = \\\"Normals_Frequency\\\"\\n normalVAF = \\\"Normals_median_VAF\\\"\\n bolli_cl = \\\"Bolli_Class\\\"\\n bolli_freq = \\\"Bolli_Frequency\\\"\\n bolli_positions = \\\"Bolli_Positions\\\"\\n bolli_anno = \\\"Bolli_Annotation\\\"\\n record = [ record, cl, freq, medVAF, Q25, Q75, positions, bolli_cl, bolli_freq, bolli_anno, bolli_positions, normal, normalVAF ]\\n record = (\\\"\\\\t\\\".join(record))\\n print(record)\\n continue\\n\\n try:\\n chrom = str(recArr[3])\\n pos = int(recArr[4])\\n start = int(recArr[4]) - 9\\n end = int(recArr[4]) + 9\\n if (chrom, pos) in mmrfC.index:\\n cl = \\\"genomic_exact\\\"\\n freq = str(mmrfC.loc[(chrom,pos)])\\n medVAF = str(mmrfM.loc[(chrom,pos)])\\n Q25 = str(mmrfQ25.loc[(chrom,pos)])\\n Q75 = str(mmrfQ75.loc[(chrom,pos)])\\n positions = str(pos)\\n record = [ record, cl, freq, medVAF, Q25, Q75, positions ]\\n record = (\\\"\\\\t\\\".join(record))\\n flag = 1\\n if flag == 0:\\n mmrfCsub=mmrfC.loc[chrom]\\n if not mmrfCsub[(mmrfCsub.index >= start) & (mmrfCsub.index <= end)].empty:\\n for i in mmrfCsub[(mmrfCsub.index >= start) & (mmrfCsub.index <= end)].index.values:\\n cl = \\\"genomic_close\\\"\\n freq.append(str(mmrfC.loc[(chrom,i)]))\\n medVAF.append(str(mmrfM.loc[(chrom,i)]))\\n Q25.append(str(mmrfQ25.loc[(chrom,i)]))\\n Q75.append(str(mmrfQ75.loc[(chrom,i)]))\\n positions.append(str(i))\\n freq = (\\\":\\\".join(freq))\\n medVAF = (\\\":\\\".join(medVAF))\\n Q25 = (\\\":\\\".join(Q25))\\n Q75 = (\\\":\\\".join(Q75))\\n positions = (\\\":\\\".join(positions))\\n record = [ record, cl, freq, medVAF, Q25, Q75, positions ]\\n record = (\\\"\\\\t\\\".join(record))\\n else:\\n cl = \\\"NA\\\"\\n freq = \\\"NA\\\"\\n medVAF = \\\"NA\\\"\\n Q25 = \\\"NA\\\"\\n Q75 = \\\"NA\\\"\\n positions = \\\"NA\\\"\\n record = [ record, cl, freq, medVAF, Q25, Q75, positions ]\\n record = (\\\"\\\\t\\\".join(record))\\n\\n\\n except:\\n cl = \\\"NA\\\"\\n freq = \\\"NA\\\"\\n medVAF = \\\"NA\\\"\\n Q25 = \\\"NA\\\"\\n Q75 = \\\"NA\\\"\\n positions = \\\"NA\\\"\\n record = [ record, cl, freq, medVAF, Q25, Q75, positions ]\\n record = (\\\"\\\\t\\\".join(record))\\n\\n\\n\\n try:\\n chrom = str(recArr[3])\\n pos = int(recArr[4])\\n start = int(recArr[4]) - 9\\n end = int(recArr[4]) + 9\\n if (chrom, pos) in nicollo_counts.index:\\n bolli_cl = \\\"genomic_exact\\\"\\n bolli_freq = str(nicollo_counts.loc[(chrom,pos)]) \\n bolli_positions = str(pos)\\n bolli_anno = str(nol_var.loc[chrom, pos]['Variant_class'].values[0])\\n record = [ record, bolli_cl, bolli_freq, bolli_anno, bolli_positions ]\\n record = (\\\"\\\\t\\\".join(record))\\n bolli_flag = 1\\n\\n\\n if bolli_flag == 0: \\n nicollo_counts_sub=nicollo_counts.loc[chrom]\\n if not nicollo_counts_sub[(nicollo_counts_sub.index >= start) & (nicollo_counts_sub.index <= end)].empty:\\n for i in nicollo_counts_sub[(nicollo_counts_sub.index >= start) & (nicollo_counts_sub.index <= end)].index.values:\\n #if not nicollo_counts_sub.ix[start:end].empty:\\n # for i in nicollo_counts_sub.ix[start:end].index.values:\\n #print(\\\"XXXXXXX\\\",i, nicollo_counts_sub.loc[(chrom,i)], start, end)\\n bolli_cl = \\\"genomic_close\\\"\\n bolli_freq.append(str(nicollo_counts.loc[(chrom,i)]))\\n bolli_anno.append(str(nol_var.loc[(chrom,i)]['Variant_class'].values[0]))\\n bolli_positions.append(str(i))\\n bolli_freq = (\\\":\\\".join(bolli_freq))\\n bolli_positions = (\\\":\\\".join(bolli_positions))\\n bolli_anno = (\\\":\\\".join(bolli_anno))\\n record = [ record, bolli_cl, bolli_freq, bolli_anno, bolli_positions ]\\n record = (\\\"\\\\t\\\".join(record))\\n else:\\n bolli_cl = \\\"NA\\\"\\n bolli_freq = \\\"NA\\\"\\n bolli_positions = \\\"NA\\\"\\n bolli_anno = \\\"NA\\\"\\n record = [ record, bolli_cl, bolli_freq, bolli_anno, bolli_positions ]\\n record = (\\\"\\\\t\\\".join(record))\\n\\n\\n except:\\n bolli_cl = \\\"NA\\\"\\n bolli_freq = \\\"NA\\\"\\n bolli_anno = \\\"NA\\\"\\n bolli_positions = \\\"NA\\\"\\n record = [ record, bolli_cl, bolli_freq, bolli_anno, bolli_positions ]\\n record = (\\\"\\\\t\\\".join(record))\\n\\n\\n normal = \\\"0\\\"\\n normalVAF = \\\"0\\\"\\n try:\\n chrom=str(recArr[3])\\n pos=int(recArr[4])\\n normal = counts_tsv.loc[(chrom,pos),\\\"count\\\"]\\n normal = normal.ix[0]\\n normal = str(normal)\\n\\n normalVAF = str(counts_median.loc[(chrom,pos)])\\n\\n record = [ record, normal, normalVAF ]\\n record = (\\\"\\\\t\\\".join(record))\\n print(record)\\n\\n except:\\n normal = \\\"0\\\"\\n normalVAF = \\\"0\\\"\\n record = [ record, str(normal), str(normalVAF) ]\\n record = (\\\"\\\\t\\\".join(record))\\n print(record)\",\n \"def word_analogy(self):\\n data = open(\\\"data/word_analogy_subset.en.ar.txt\\\").read().split('\\\\n')\\n data = [x for x in data if len(x.split()) == 4]\\n cnt = 0\\n keys = list(self.embeddings_index.keys())\\n vectors = np.array(list(self.embeddings_index.values()))\\n norms = np.linalg.norm(vectors, axis=1)\\n for i in data:\\n i = self.preprocessor(i).split()\\n try:\\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\\n except:\\n continue\\n unit = v / np.linalg.norm(v)\\n dists = np.dot(vectors, unit) / norms\\n best = np.argpartition(-dists, 10)[:10 + 1]\\n best = best.take(np.argsort((-dists).take(best)))\\n result = [(keys[sim], float(dists[sim]))\\n for sim in best]\\n sbv = result[:10]\\n for j in sbv:\\n if j[0] == i[3]:\\n cnt += 1\\n return cnt/ len(data)\",\n \"def _get_num_syllables(doc: Doc, min_syllables: int = 1):\\n text = (word for word in doc if not word.is_punct and \\\"'\\\" not in word.text)\\n syllables_per_word = tuple(syllapy.count(word.text) for word in text)\\n return sum(c for c in syllables_per_word if c >= min_syllables)\",\n \"def count_words_and_dublicates(novel):\",\n \"def __yago_counts(self):\\n\\n num_lines = 0\\n print(\\\"Calculating Yago occurrences\\\")\\n custom_freq = {}\\n with open(\\n os.path.join(self.base_url, \\\"generic/p_e_m_data/aida_means.tsv\\\"),\\n \\\"r\\\",\\n encoding=\\\"utf-8\\\",\\n ) as f:\\n for line in f:\\n num_lines += 1\\n\\n if num_lines % 5000000 == 0:\\n print(\\\"Processed {} lines.\\\".format(num_lines))\\n\\n line = line.rstrip()\\n line = unquote(line)\\n parts = line.split(\\\"\\\\t\\\")\\n mention = parts[0][1:-1].strip()\\n\\n ent_name = parts[1].strip()\\n ent_name = ent_name.replace(\\\"&\\\", \\\"&\\\")\\n ent_name = ent_name.replace(\\\""\\\", '\\\"')\\n\\n x = ent_name.find(\\\"\\\\\\\\u\\\")\\n while x != -1:\\n code = ent_name[x : x + 6]\\n replace = unicode2ascii(code)\\n if replace == \\\"%\\\":\\n replace = \\\"%%\\\"\\n\\n ent_name = ent_name.replace(code, replace)\\n x = ent_name.find(\\\"\\\\\\\\u\\\")\\n\\n ent_name = self.wikipedia.preprocess_ent_name(ent_name)\\n if ent_name in self.wikipedia.wiki_id_name_map[\\\"ent_name_to_id\\\"]:\\n if mention not in custom_freq:\\n custom_freq[mention] = {}\\n ent_name = ent_name.replace(\\\" \\\", \\\"_\\\")\\n if ent_name not in custom_freq[mention]:\\n custom_freq[mention][ent_name] = 1\\n\\n return custom_freq\",\n \"def process(self):\\n\\n linelang = defaultdict(int)\\n wordlang = defaultdict(int)\\n\\n linefont = defaultdict(int)\\n wordfont = defaultdict(int)\\n\\n inputfiles = self.input_files\\n for input_file in inputfiles:\\n\\n alignurl = input_file.url\\n pcgts = parse(alignurl, True)\\n page = pcgts.get_Page()\\n regions = page.get_TextRegion()\\n\\n for region in regions:\\n lines = region.get_TextLine()\\n\\n for line in lines:\\n try:\\n llang = line.primaryLanguage\\n linelang[llang] += 1\\n except TypeError:\\n pass\\n\\n try:\\n lfont = line.fontFamily\\n linefont[lfont] += 1\\n except TypeError:\\n pass\\n\\n words = line.get_Word()\\n for word in words:\\n try:\\n wlang = word.language\\n wordlang[wlang] += 1\\n except TypeError:\\n pass\\n\\n try:\\n wfont = word.get_TextStyle().fontFamily\\n wordfont[wfont] += 1\\n except TypeError:\\n pass\\n\\n #predominant language\\n try:\\n lang = max(linelang, key=lambda k: linelang[k])\\n except TypeError:\\n try:\\n lang = max(wordlang, key=lambda k: wordlang[k])\\n except TypeError:\\n lang = 'German'\\n\\n #predominant font\\n try:\\n font = max(linefont, key=lambda k: linefont[k])\\n except TypeError:\\n try:\\n font = max(wordfont, key=lambda k: wordfont[k])\\n except TypeError:\\n font = 'Antiqua'\\n\\n\\n print(lang)\\n print(font)\",\n \"def update_syllable_count(word, syll_count):\\n\\n syllables = word.split('-')\\n for i in range(1, 4):\\n for j in range(len(syllables) - i + 1):\\n gram = '-'.join(syllables[j: j + i])\\n count = syll_count.setdefault(gram, 0)\\n syll_count[gram] = count + 1\",\n \"def corpora_stats(output):\\n igFiles = []\\n for root, directories, filenames in os.walk(output + \\\"/ig/\\\"):\\n for filename in filenames:\\n igFiles.append(os.path.join(root, filename))\\n igFiles = filter(lambda x: \\\".txt\\\" in x, igFiles)\\n words = []\\n for file in igFiles:\\n fileH = open(file, \\\"r\\\")\\n words = words + fileH.read().split(\\\" \\\")\\n print(\\\"Number of words in IG corpus: {}\\\".format(len(words)))\\n print(\\\"Vocabulary size of IG corpus: {}\\\".format(len(set(words))))\",\n \"def __init__(self, n, sents):\\n assert n > 0\\n self._n = n\\n print(\\\"Counting...\\\")\\n count = defaultdict(int)\\n while n >= 0:\\n for sent in sents:\\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\\n s.insert(0, \\\"<s>\\\")\\n s.append(\\\"</s>\\\")\\n for i in range(len(s) - n + 1):\\n count[tuple(s[i:i + n])] += 1\\n n -= 1\\n count[()] = count[()] - count[('<s>',)] - count[\\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\\n self._count = count\\n print(\\\"Computing vocabulary...\\\")\\n self._voc = voc = set()\\n for sent in sents:\\n voc = voc.union(set(sent))\\n voc.add('</s>')\\n self._voc = voc\\n self._V = len(voc) # vocabulary size\\n print(\\\"Done\\\")\",\n \"def process_corpus(args):\\n\\n fs = open(args.input,'r')\\n out = list()\\n for line in fs:\\n blob = TextBlob(line.strip())\\n result_info = dict()\\n result_info\\n result_info['correct'] = str(blob.correct())\\n if args.parse :\\n result_info['parse'] = get_parsed_text(blob)\\n if args.tokenize:\\n result_info['tokenize'] = get_tokenizer_result(blob)\\n if args.sentiment:\\n result_info['sentiment'] = analyze_sentiment(blob)\\n if args.sentence_sentiment:\\n result_info['sentence_sentiment'] = analyze_sentence_sentiment(blob)\\n if args.noun_phrase:\\n result_info['noun_phrase'] = get_noun_phrases(blob)\\n if args.pos:\\n result_info['pos'] = get_pos_tags(blob)\\n\\n out.append(result_info)\\n print out\\n json.dump(out,open('out.json','w'))\\n fs.close()\\n print '******************************* Execution completed *********************************'\",\n \"def tokenize_and_split_bis(sms_file):\\n \\n dic = {}\\n list1 = []\\n list2 = []\\n list3 = []\\n list4 = []\\n i = -1\\n document = 0\\n terms = 0\\n new_document = True\\n ham = True\\n for line in open(sms_file, 'r').readlines():\\n w = []\\n document += 1\\n new_document = True\\n for word in line.split():\\n i = i + 1\\n if word == \\\"ham\\\":\\n ham = True\\n i = i - 1\\n elif word == \\\"spam\\\":\\n ham = False\\n i = i - 1\\n else:\\n if word not in dic:\\n dic[word] = i\\n w.append(dic[word])\\n list3.append(1)\\n list4.append(1)\\n new_document = False\\n terms += 1\\n else : \\n i = i - 1\\n w.append(dic[word])\\n list4[dic[word]] += 1\\n terms += 1\\n if new_document: \\n list3[dic[word]] += 1\\n new_document = False\\n \\n if ham and w !=[]:\\n list2.append(w)\\n elif ham == False and w !=[]:\\n list1.append(w)\\n\\n moy = 0\\n len_dic = len(dic.keys())\\n list5 = [0 for x in range(len_dic)]\\n for key in dic.keys():\\n if list4[dic[key]] > 0:\\n tf = list4[dic[key]] / terms\\n idf = math.log(document / list3[dic[key]])\\n tfIdf = tf * idf\\n list5[dic[key]] = tfIdf\\n # print(\\\"the word \\\" + str(key) + \\\" appairs \\\" + str(list4[dic[key]]) + \\\" times.\\\")\\n # print(\\\"his frequency is \\\" + str(list4[dic[key]] / terms) )\\n # print(\\\"the word \\\" + str(key) + \\\" appairs \\\" + str(list3[dic[key]]) + \\\" times in each document.\\\")\\n # print(\\\"his frequency is \\\" + str(idf))\\n # print(\\\"utility \\\" + str(tfIdf))\\n moy += tfIdf\\n \\n moy = moy / len_dic \\n # print(moy)\\n dic_bis = {}\\n i = -1\\n for key in dic.keys():\\n value = list5[dic[key]]\\n # print(str(value))\\n if (value > oracle * moy):\\n i += 1\\n dic_bis[key] = i\\n # else:\\n # print(\\\"not pass \\\" + key + \\\" \\\" + str(value))\\n \\n \\n # print(dic_bis == dic)\\n # print(dic)\\n return dic_bis,list1,list2\",\n \"def estimate(word):\\n parts = re.split(r'[^aeiouy]+', word)\\n valid_parts = []\\n\\n for part in parts:\\n if part != '':\\n valid_parts.append(part)\\n\\n syllables = 0\\n\\n for p in re_subsyllables:\\n if p.match(word):\\n syllables -= 1\\n\\n for p in re_addsyllables:\\n if p.match(word):\\n syllables += 1\\n\\n syllables += len(valid_parts)\\n\\n if syllables <= 0:\\n syllables = 1\\n\\n return syllables\",\n \"def countsyllables_en(word):\\r\\n\\tif not word:\\r\\n\\t\\treturn 0\\r\\n\\r\\n\\t# Remove final silent 'e'\\r\\n\\tif word[-1] == \\\"e\\\":\\r\\n\\t\\tword = word[:-1]\\r\\n\\r\\n\\t# Check for a cached syllable count\\r\\n\\tif word in fallback_cache:\\r\\n\\t\\treturn fallback_cache[word]\\r\\n\\r\\n\\t# Count vowel groups\\r\\n\\tresult = 0\\r\\n\\tprev_was_vowel = False\\r\\n\\tfor char in word:\\r\\n\\t\\tis_vowel = char in VOWELS or char == 'y'\\r\\n\\t\\tif is_vowel and not prev_was_vowel:\\r\\n\\t\\t\\tresult += 1\\r\\n\\t\\tprev_was_vowel = is_vowel\\r\\n\\r\\n\\t# Add & subtract syllables\\r\\n\\tfor r in fallback_addsyl:\\r\\n\\t\\tif r.search(word):\\r\\n\\t\\t\\tresult += 1\\r\\n\\tfor r in fallback_subsyl:\\r\\n\\t\\tif r.search(word):\\r\\n\\t\\t\\tresult -= 1\\r\\n\\r\\n\\t# Cache the syllable count\\r\\n\\tfallback_cache[word] = result\\r\\n\\r\\n\\treturn result\",\n \"def train(self, corpus): \\n for sentence in corpus.corpus:\\n prev_word = None\\n for datum in sentence.data:\\n word = datum.word\\n self.unigram_count[word] += 1\\n if prev_word != None:\\n self.bigram_count[prev_word][word] += 1\\n prev_word = word\\n \\n self.vocabulary_size = len(self.unigram_count)\\n self.num_words = sum(self.unigram_count.values())\",\n \"def analyze_text (self, testing_string): \\n self.length = len(self.testing_string)\\n self.total_words = (self.testing_string).split()\\n self.total_unique_words = set(self.total_words)\\n\\n self.total_characters = (int)(0)\\n for ch in self.testing_string :\\n if(ch.isspace() != True):\\n self.total_characters = self.total_characters + 1 \\n\\n self.total_unique_characters = set(self.testing_string)\\n \\n Linguist.about_given_string[\\\"Length\\\"] = self.length\\n Linguist.about_given_string[\\\"Total_words\\\"] = len(self.total_words)\\n Linguist.about_given_string[\\\"Total_unique_words\\\"] = len(self.total_unique_words)\\n Linguist.about_given_string[\\\"Total_characters\\\"] = self.total_characters\\n Linguist.about_given_string[\\\"Total_unique_characters\\\"] = len(self.total_unique_characters)\",\n \"def num_syllables(self, word):\\n \\\"\\\"\\\"\\n using the logic of vowel counting, count all vowels in the pronunciations\\n \\\"\\\"\\\"\\n dictionary = self._pronunciations;\\n # check if word is present in the CMU dictionary\\n if word in dictionary :\\n word_pronunciations = dictionary[word.lower()]\\n else :\\n return 1\\n \\n vowels = ['A', 'E', 'I', 'O', 'U']\\n \\n ## find the shorter pronunciation for word\\n shorter_arr = [];\\n for pronunciation in word_pronunciations :\\n if len(pronunciation) > len(shorter_arr) : shorter_arr = pronunciation\\n \\n num_length = 0\\n \\n for phoneme in shorter_arr :\\n if phoneme[:1] in vowels : num_length += 1\\n \\n return num_length\",\n \"def train(self, corpus):\\n lastToken = \\\"#\\\"\\n for sentence in corpus.corpus:\\n for datum in sentence.data:\\n token = datum.word\\n self.reverseBigramCount[token][lastToken] += 1\\n self.bigramCount[lastToken][token] += 1\\n self.unigramCount[token] += 1\\n self.total += 1\\n lastToken = token\",\n \"def syllable_dict():\\n counts = dict()\\n \\n with open('data/Syllable_dictionary.txt') as file:\\n for line in file:\\n arr = line.split(' ', 1)\\n if 'E' in arr[1]:\\n cts = arr[1].split(' ', 1)\\n counts[arr[0].strip('\\\\'')] = int(cts[1][0])\\n counts[(arr[0].strip('\\\\'') + \\\"_\\\")] = int(cts[0][1])\\n else:\\n counts[arr[0].strip('\\\\'')] = int(arr[1][0])\\n return counts\",\n \"def train(self, corpus):\\n for sentence in corpus.corpus:\\n cleanSentence = sentence.cleanSentence()\\n for datum in cleanSentence.data:\\n token = datum.word\\n self.unigramCounts[token] = self.unigramCounts[token] + 1\\n self.total += 1\\n\\n i = 0\\n while i < len(sentence.data) - 1:\\n token = str(cleanSentence.get(i))\\n self.followingWords[token].add(str(cleanSentence.get(i+1)))\\n i += 1\\n\\n i = 1\\n while i < len(sentence.data):\\n bigram = str(cleanSentence.get(i-1)) + \\\" \\\" + str(cleanSentence.get(i))\\n self.bigramCounts[bigram] = self.bigramCounts[bigram] + 1\\n\\n self.precedingWords[str(cleanSentence.get(i))].add(str(cleanSentence.get(i-1)))\\n i += 1\\n self.precedingWordsTotal = sum(map(lambda x: len(x), self.precedingWords.values()))\\n\\n i = 2\\n while i < len(sentence.data):\\n trigram = str(cleanSentence.get(i-2)) + \\\" \\\" + str(cleanSentence.get(i-1)) + \\\" \\\" + str(cleanSentence.get(i))\\n self.trigramCounts[trigram] = self.trigramCounts[trigram] + 1\\n i += 1\\n\\n #print('precedingWords')\\n #print(self.precedingWords)\\n #print('followingWords')\\n #print(self.followingWords)\\n #print('unigrams')\\n #print(self.unigramCounts)\\n #print('bigrams')\\n #print(self.bigramCounts)\\n\\n #self.discount(self.trigramCounts)\\n #self.discount(self.bigramCounts)\\n #self.discount(self.unigramCounts)\",\n \"def findSubcorpora():\\n counterTwo = 0\\n\\n with open('bc.processed2.csv', 'r') as readfile:\\n for line in readfile:\\n counterTwo += 1\\n if re.match('^<subcorpus', line):\\n print(str(counterTwo) + '\\\\t' + line + '\\\\n')\",\n \"def get_feature_set_SB(tweet):\\n #pos-tag frequencies\\n# print \\\"Tagged words in tweet: \\\", tweet.tagged_words\\n pos_tag_freq = {}\\n additional_freq = {}\\n for phrase in tweet.tagged_words:\\n for word in phrase:\\n try:\\n tag = word['pos']\\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# if tag=='PRtinf':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJS':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJ':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='NP':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='DET':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='P':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n if tag in ADJECTIVES:\\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\\n elif tag in ADVERBS: \\n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\\n elif tag in PRONOUNS:\\n additional_freq['pronoun'] = 1\\n except KeyError:\\n continue\\n# print \\\"Tag frequencies: \\\", pos_tag_freq\\n for key in pos_tag_freq.keys():\\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \\n #Number of exclamation marks, number of emoticons,\\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\\n if emoticons>0:\\n additional_freq['emoticons'] = emoticons*1.0\\n if tweet.nrof_exclamations>0:\\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\\n \\n# print \\\"Additional frequencies: \\\", additional_freq\\n# raw_input(\\\"Continue?\\\")\\n \\n #Concatenate the dicts\\n features= dict(pos_tag_freq.items() + additional_freq.items())\\n# print \\\"All features: \\\", features\\n# raw_input(\\\"Continue?\\\")\\n return features\",\n \"def count_syllables(book):\\n d = dict(cmudict.entries())\\n with open(book, 'r') as myfile:\\n booky = myfile.read().lower()\\n tokenized_book = nltk.word_tokenize(booky)\\n\\n count = 0\\n for word in tokenized_book:\\n count += ( nsly(word, d))\\n\\n return count\",\n \"def setCounts(self):\\n N=len(self.y)\\n self.counts=np.zeros(len(self.y))\\n self.idf=np.zeros(len(self.y))\\n for i in range(0,len(self.counts)):\\n for word in self.qtext:\\n wc=self.atext[i].count(word)\\n self.counts[i]+=wc\\n if wc>0:\\n d=0\\n for sentence in self.atext:\\n if word in sentence:\\n d+=1\\n self.idf[i]+=wc*np.log(N/d)\",\n \"def analyze_social_patterns(input_file):\\n # First read in the spelling variants\\n # standard, non standard\\n # us, uk spelling\\n standard_non_standard_pairs = util.read_variants_from_file(input_file)\\n all_forms = set()\\n all_forms = all_forms.union(standard_non_standard_pairs.keys())\\n all_forms = all_forms.union(standard_non_standard_pairs.values())\\n \\n # Keeping track of stats\\n subreddit_count_standard = {}\\n subreddit_count_non_standard = {}\\n\\n # Data\\n sentences_metadata = DataWrapper.DataWrapperGzipMulti(config.REDDIT_PROCESSED_DATA,\\n config.REDDIT_METADATA_DATA)\\n \\n for sentence, metadata in sentences_metadata:\\n\\n author, author_text, subreddit, link = metadata.split(\\\"\\\\t\\\")\\n\\n # Now check for tokens in our list\\n for token in sentence:\\n if token in all_forms:\\n\\n if subreddit not in subreddit_count_standard:\\n subreddit_count_standard[subreddit] = 0\\n subreddit_count_non_standard[subreddit] = 0\\n\\n # standard or US spelling\\n if token in standard_non_standard_pairs:\\n subreddit_count_standard[subreddit] += 1\\n else:\\n subreddit_count_non_standard[subreddit] += 1\\n\\n # Print out stats\\n output_file_name = os.path.splitext(os.path.basename(input_file))[0]\\n with open(output_file_name + \\\"_subreddits_distr.txt\\\", \\\"w\\\") as output_file:\\n for subreddit, count in subreddit_count_standard.items():\\n output_file.write(\\\"%s\\\\t%s\\\\t%s\\\\n\\\" % (subreddit, count, subreddit_count_non_standard[subreddit]))\",\n \"def train(self, corpus):\\n\\n\\n temp = \\\"\\\"\\n for sentence in corpus.corpus:\\n\\n i = 0\\n for datum in sentence.data:\\n # print str(sentence.data)\\n self.total=self.total+1\\n token = datum.word\\n self.unigramCounts[token] = self.unigramCounts[token] + 1\\n if (i == 0):\\n temp = datum.word\\n i = i + 1\\n continue\\n\\n i = i + 1\\n\\n key = temp + \\\",\\\" + token\\n self.bigramCounts[key] = self.bigramCounts[key] + 1\\n # print token\\n temp = token\\n\\n pass\",\n \"def getCounter(self):\\n word_count, noun_word_count = Counter(), Counter()\\n word_rating, noun_word_rating = defaultdict(list), defaultdict(list)\\n docs = self.nlp.pipe(\\n self.docs, n_process=1, disable=self.disablelayers)\\n \\n\\n for index, doc in enumerate(docs):\\n for token in doc:\\n if not token.is_stop and not token.is_punct and token.pos_ in self.pos:\\n if token.pos_ == 'PROPN':\\n word_count[token.lemma_] += 1\\n word_rating[token.lemma_].append(self.ratings[index])\\n else:\\n noun_word_count[token.lemma_] += 1\\n noun_word_rating[token.lemma_].append(self.ratings[index])\\n\\n # if 0<=proper nouns<=5 found, add regular nouns\\n if not word_count or len(word_count) <= 5:\\n word_count += noun_word_count\\n word_rating = {**word_rating, **noun_word_rating}\\n \\n word_color = {word: self.getColor(\\n ratings)[1] for word, ratings in word_rating.items()}\\n word_sentiment = {word: self.getColor(\\n ratings)[0] for word, ratings in word_rating.items()}\\n\\n return word_count, word_color, word_sentiment\",\n \"def count_syllables_in_word(word):\\n\\n count = 0\\n\\n endings = '!,;.?:'\\n last_char = word[-1]\\n\\n if last_char in endings:\\n processed_word = word[0:-1]\\n else:\\n processed_word = word\\n\\n\\n if len(processed_word) <= 3:\\n return 1\\n if processed_word[-1] in 'Ee':\\n processed_word = processed_word[0:-1]\\n\\n vowels = 'aeiouAEIOU'\\n prev_char_was_vowel = False\\n\\n for char in processed_word:\\n if char in vowels:\\n if not prev_char_was_vowel:\\n count += 1\\n prev_char_was_vowel = True\\n\\n else:\\n prev_char_was_vowel = False\\n\\n if processed_word[-1] in 'yY':\\n count += 1\\n \\n\\n return count\",\n \"def main():\\n token_dict_dict = {}\\n all_dict = {}\\n pronoun_proportion_list = []\\n tag = 'PRP' # base tag for all pronouns, see 'https://www.clips.uantwerpen.be/pages/MBSP-tags' for more info\\n\\n for text in glob.glob(file_loc):\\n file_title = os.path.basename(text).split('.')[0]\\n\\n with open(text, 'r') as f:\\n speech = f.read()\\n text_dict = {}\\n\\n try:\\n #TextBlob goodness that tags all the words for me\\n speech_blob = TextBlob(clean(speech))\\n speech_blob.tags\\n except:\\n #for some reason Trump's address contained a unicode 128 character that I couldn't find\\n #instead of getting rid of it in a single file, i decided to have an except that could catch that case in\\n #all sitations and handle them accordingly\\n\\n #lets the user know that there was an issue, and that it's been handled\\n print file_title,\\n print \\\"contains unexpected unicode characters. they have been removed and the document has been processed\\\"\\n\\n #gets rid of all unicode characters. i could do this by default, but all the other files ran fine\\n #so i didn't think it was worth it\\n speech_blob = TextBlob(clean(speech.decode('unicode_escape').encode('ascii','ignore')))\\n\\n for token in speech_blob.tags:\\n # builds the inital dictionary of data, only looks at words with a specified tag\\n if tag in token[1]:\\n try:\\n text_dict[token[0]] += 1\\n except:\\n text_dict[token[0]] = 1\\n try:\\n all_dict[token[0]] += 1\\n except:\\n all_dict[token[0]] = 1\\n #breaks the title into 3 pieces: number, president, date\\n token_dict_dict[file_title] = text_dict\\n partial_split, date = string.rsplit(file_title, '_', 1)\\n num_pres, pres = string.split(partial_split, '_', 1)\\n\\n pronoun_proportion_list.append(\\n (pres, date, total_to_proportion(pronoun_breakdown(token_dict_dict[file_title])))\\n )\\n create_pronoun_graph(sort_list_by_president_order(pronoun_proportion_list))\",\n \"def get_vocabulary(text_fname, vocab_fname):\\n with codecs.open(text_fname,'r','utf-8') as infile, \\\\\\n codecs.open(vocab_fname,'w','utf-8') as outfile: \\n\\n count_map={}\\n for line in infile:\\n sent=line.strip().split(' ')\\n for w in sent:\\n count_map[w]=count_map.get(w,0.0)+1.0\\n\\n for w,c in count_map.iteritems(): \\n outfile.write(u'{}|{}\\\\n'.format(w,c))\",\n \"def getTextStatsFeat(text, stemmRequired = True,\\r\\n excludeStopwordsRequired = True):\\r\\n #length = len(text)\\r\\n sentenceCount = len(re.findall(\\\"[.?!]\\\", text))\\r\\n exclamationMarkCount = len(re.findall(\\\"[!]\\\", text))\\r\\n questionMarkCount = len(re.findall(\\\"[?]\\\", text))\\r\\n digitsCount = len(re.findall(\\\"[0-9]+\\\", text))\\r\\n text = text.replace(\\\",\\\", \\\" \\\").replace(\\\".\\\", \\\" \\\")\\r\\n cleanText = re.sub('[^a-zа-я0-9]', ' ', text.lower())\\r\\n wordCount = 0.0\\r\\n charCount = 0.0\\r\\n rusCharCount = 0.0\\r\\n engCharCount = 0.0\\r\\n if excludeStopwordsRequired:\\r\\n for w in cleanText.split():\\r\\n if len(w)>1 and w not in stopwords:\\r\\n if not (not stemmRequired or re.search(\\\"[0-9a-z]\\\", w)):\\r\\n w = stemmer.stem(w)\\r\\n wordCount += 1\\r\\n c, rus, eng = getWordCharCount(w)\\r\\n charCount += c\\r\\n rusCharCount += rus\\r\\n engCharCount += eng\\r\\n else:\\r\\n for w in cleanText.split():\\r\\n if len(w)>1:\\r\\n if not (not stemmRequired or re.search(\\\"[0-9a-z]\\\", w)):\\r\\n w = stemmer.stem(w)\\r\\n wordCount += 1\\r\\n c, rus, eng = getWordCharCount(w)\\r\\n charCount += c\\r\\n rusCharCount += rus\\r\\n engCharCount += eng\\r\\n # per sentence\\r\\n wordPerSentence = tryDivide(wordCount, sentenceCount)\\r\\n charPerSentence = tryDivide(charCount, sentenceCount)\\r\\n rusCharPerSentence = tryDivide(rusCharCount, sentenceCount)\\r\\n engCharPerSentence = tryDivide(engCharCount, sentenceCount)\\r\\n # per word\\r\\n charPerWord = tryDivide(charCount, wordCount)\\r\\n rusCharPerWord = tryDivide(rusCharCount, wordCount)\\r\\n engCharPerWord = tryDivide(engCharCount, wordCount)\\r\\n # ratio\\r\\n rusCharRatio = tryDivide(rusCharCount, charCount)\\r\\n engCharRatio = tryDivide(engCharCount, charCount)\\r\\n rusCharVsEngChar = tryDivide(rusCharCount, engCharCount)\\r\\n engCharVsRusChar = tryDivide(engCharCount, rusCharCount)\\r\\n \\r\\n stats = [\\r\\n sentenceCount,\\r\\n wordCount,\\r\\n charCount,\\r\\n rusCharCount,\\r\\n engCharCount,\\r\\n digitsCount,\\r\\n exclamationMarkCount,\\r\\n questionMarkCount,\\r\\n wordPerSentence,\\r\\n charPerSentence,\\r\\n rusCharPerSentence,\\r\\n engCharPerSentence,\\r\\n charPerWord,\\r\\n rusCharPerWord,\\r\\n engCharPerWord,\\r\\n rusCharRatio,\\r\\n engCharRatio,\\r\\n rusCharVsEngChar,\\r\\n engCharVsRusChar,\\r\\n ]\\r\\n statsFeat = \\\"\\\"\\r\\n for i,f in enumerate(stats):\\r\\n if f != 0:\\r\\n statsFeat += \\\"%s:%s \\\" % (i+1, f)\\r\\n statsFeat = statsFeat[:-1] \\r\\n return statsFeat\",\n \"def get_text_frequencies(connection, feature, text_id):\\n tindex2mtindex = {}\\n findex2mfindex = {}\\n word_counts = Counter()\\n word_feature_pairs = set()\\n text_token_count = 0\\n unit_proj = {\\n '_id': False,\\n 'tokens.features.form': True\\n }\\n if feature != 'form':\\n unit_proj['tokens.features.'+feature] = True\\n db_cursor = connection.connection[Unit.collection].find(\\n {'text': text_id, 'unit_type': 'line'},\\n unit_proj\\n )\\n for unit in db_cursor:\\n text_token_count += len(unit['tokens'])\\n for token in unit['tokens']:\\n cur_features = token['features']\\n # use the form index as an identifier for this token's word\\n # type\\n cur_tindex = cur_features['form'][0]\\n if cur_tindex not in tindex2mtindex:\\n tindex2mtindex[cur_tindex] = len(tindex2mtindex)\\n mtindex = tindex2mtindex[cur_tindex]\\n # we want to count word types by matrix indices for faster\\n # lookup when we get to the stage of counting up word type\\n # occurrences\\n word_counts[mtindex] += 1\\n for cur_findex in cur_features[feature]:\\n if cur_findex not in findex2mfindex:\\n findex2mfindex[cur_findex] = len(findex2mfindex)\\n mfindex = findex2mfindex[cur_findex]\\n # record when a word type is associated with a feature type\\n word_feature_pairs.add((mtindex, mfindex))\\n csr_rows = []\\n csr_cols = []\\n for mtindex, mfindex in word_feature_pairs:\\n csr_rows.append(mtindex)\\n csr_cols.append(mfindex)\\n word_feature_matrix = csr_matrix(\\n (\\n np.ones(len(csr_rows), dtype=np.bool),\\n (np.array(csr_rows), np.array(csr_cols))\\n ),\\n shape=(len(tindex2mtindex), len(findex2mfindex))\\n )\\n # if matching_words_matrix[i, j] == True, then the word represented by\\n # position i shared at least one feature type with the word represented\\n # by position j\\n matching_words_matrix = word_feature_matrix.dot(\\n word_feature_matrix.transpose())\\n\\n mtindex2tindex = {\\n mtindex: tindex for tindex, mtindex in tindex2mtindex.items()}\\n freqs = {}\\n coo = matching_words_matrix.tocoo()\\n for i, j in zip(coo.row, coo.col):\\n # since only matching tokens remain, the column indices indicate\\n # which tokens match the token represented by row i; we need to\\n # count up how many times each word appeared\\n cur_token = mtindex2tindex[i]\\n if cur_token not in freqs:\\n freqs[cur_token] = word_counts[j]\\n else:\\n freqs[cur_token] += word_counts[j]\\n for tok_ind in freqs:\\n freqs[tok_ind] = freqs[tok_ind] / text_token_count\\n return freqs\",\n \"def get_word2freq_and_pos(self, files: List[str]) -> Tuple[Dict[str, int], List[str]]:\\n word2freq = defaultdict(int)\\n pos_list = []\\n\\n logger.info(\\\"Tokenization\\\")\\n for file in files:\\n logger.info(\\\"\\\\tReading file: {}\\\".format(file))\\n with open(file, 'r') as f:\\n for line in tqdm(f):\\n line = line.strip()\\n if line != \\\"\\\":\\n for m in self.tokenize(line):\\n word2freq[self.word_formatter(m)] += 1\\n pos_list.append(pos_substitution_format(m))\\n\\n return word2freq, list(set(pos_list))\",\n \"def word_count(self):\\n print(self.words())\\n return len(self.words())\\n #count = 0\\n #for lines in self.lines:\\n # line = lines.strip(os.linesep)\\n # wordslst = line.split()\\n # count += len(wordslst)\\n #return count\\n #joined_string = ''.join(self.lines)\\n #for word in joined_string:\\n # if word != ' ' and word != '\\\\n' and word != '\\\\t':\\n # count += 1\\n #print('READ ME ––––––––––', self.lines)\\n #print(joined_string)\\n #print(line)\\n #print(wordslst)\\n #print(count)\",\n \"def _counter(title_list):\\n t = Tokenizer()\\n words_count = defaultdict(int)\\n words = []\\n for title in title_list:\\n tokens = t.tokenize(title)\\n for token in tokens:\\n pos = token.part_of_speech.split(',')[0]\\n if pos == '名詞':\\n words_count[token.base_form] += 1\\n words.append(token.base_form)\\n return words_count, words\",\n \"def analyze(self, word_count_thresh):\",\n \"def count_words_fast(text):\\n skip = [\\\",\\\",\\\".\\\",\\\";\\\",\\\":\\\",\\\"'\\\",'\\\"']\\n for ch in skip:\\n text = text.replace('ch',\\\"\\\")\\n \\n word_counts = Counter(text.split(\\\" \\\"))\\n return word_counts\",\n \"def anlSentence(self, sentence):\\n cleanStr = re.sub(self._wrdSeps, \\\" \\\",\\n re.sub(self._stcSeps, \\\"\\\", sentence))\\n for word in cleanStr.split():\\n self._wordCounter[word] += 1\\n self._totalWords += 1\\n else:\\n self._totalSentences += 1\",\n \"def alice_in_wonderland():\\n from collections import Counter\\n with open(\\\"lib/alice_in_wonderland.txt\\\") as f:\\n #~ table = maketrans(\\\" \\\",\\\" \\\")\\n #~ wordlist = f.read().lower().translate(table, punctuation).split()\\n # Translate actually performs fastest here but we use list comprehension\\n # because we like it.\\n wordlist = [i.lower() for i in f.read().split() if i.isalpha()]\\n counted_words = Counter(wordlist)\\n # Sort and write our counted wordlist to a new file:\\n with open(\\\"lib/alice_counted.txt\\\", \\\"w\\\") as fout:\\n length = 0\\n for k, v in sorted(counted_words.items()):\\n if len(k) > length:\\n length = len(k)\\n print length\\n fout.write(k + \\\" \\\" + str(v) + \\\"\\\\n\\\")\\n\\n # 3 Solutions for counting characters (not words):\\n #~ import operator\\n #~ from string import lowercase, punctuation\\n \\n # 1: Reading the file into a string, then performing dictionary comprehension.\\n #~ s = f.read().lower()\\n #~ # Incredibly stupid and slow because it goes through the whole string\\n #~ # with each iteration. DO NOT DO THIS.\\n #~ L = {i: s.count(i) for i in s if i in lowercase}\\n #~ L_sorted = sorted(L.iteritems(), key=operator.itemgetter(0))\\n #~ print L_sorted\\n\\n # 2: Reading the file line by line into a dictionary.\\n #~ d = {}\\n #~ for i in f:\\n #~ i = i.lower().strip()\\n #~ i = [c for c in i if c in lowercase]\\n #~ for char in i:\\n #~ if char in d:\\n #~ d[char] += 1\\n #~ else:\\n #~ d[char] = 1\\n #~ keys = d.keys()\\n #~ keys.sort()\\n #~ for i in keys:\\n #~ print (i, d[i]),\\n\\n # 3: Using Counter\\n #~ s = [i for i in f.read().lower() if i in lowercase]\\n #~ d = Counter(s)\\n # Long version:\\n #~ keys = sorted(d.keys())\\n #~ for i in keys:\\n #~ print (i, d[i]),\\n #~ # Concise:\\n #~ for k, v in sorted(d.items()): print (k, v),\",\n \"def trainInternal():\\n\\n con_counts = Counter()\\n deflike = Counter()\\n\\n for record in records:\\n data = [re.split(\\\"\\\\t\\\", d) for d in re.split(\\\"\\\\n\\\", record)]\\n tokens, tags = zip(*data)\\n\\n for i, token in enumerate(tokens):\\n denom = len(token)\\n for indices, f in fqs(token, 0.5): #perform analysis on one word at a time\\n context, numer = internalContext(indices, token)\\n if tags[i] != \\\"O\\\": #only want the named entities\\n deflike[context] += f * numer/denom #need to normalize by word length\\n con_counts[context] += f * numer/denom\\n\\n deflike = Counter({context: deflike[context]/con_counts[context] for context in deflike}) #perform division on each entry\\n\\n return deflike\",\n \"def analyze(self, text):\\n\\n # start from 0 for each Analyser variable\\n self.positives = 0\\n self.negatives = 0\\n\\n # precise self text value\\n self.text = text\\n\\n # declare a tokenased word\\n tokenizer = nltk.tokenize.TweetTokenizer()\\n tokens = tokenizer.tokenize(text)\\n\\n # indicate the length of list tokens\\n size = len(tokens)\\n\\n # all the word stuff to ckeck\\n for word in tokens:\\n\\n # chaque mots est converti en mot sans majuscule\\n word = str.lower(word)\\n\\n linespos = [line.rstrip('\\\\n') for line in open('positive-words.txt')]\\n linesneg = [line.rstrip('\\\\n') for line in open('negative-words.txt')]\\n\\n # check for positive or negative or neutral words\\n if word in linespos:\\n self.positives += 1\\n elif word in linesneg:\\n self.negatives += 1\\n else:\\n continue\\n\\n # score calculculated and reurned\\n score = self.positives - self.negatives\\n\\n return score\",\n \"def get_feature_set_SC(tweet, sentimentvalues):\\n pos_tag_freq = {}\\n additional_freq = {}\\n for phrase in tweet.tagged_words:\\n for word in phrase:\\n try:\\n tag = word['pos']\\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# if tag=='PRtinf':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJS':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJ':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='NP':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='DET':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='P':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n if tag in ADJECTIVES:\\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\\n elif tag in ADVERBS: \\n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\\n elif tag in PRONOUNS:\\n additional_freq['pronoun'] = 1\\n except KeyError:\\n continue\\n for key in pos_tag_freq.keys():\\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \\n #Number of exclamation marks, number of emoticons,\\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\\n if emoticons>0:\\n additional_freq['emoticons'] = emoticons*1.0\\n if tweet.nrof_exclamations>0:\\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\\n \\n #Add lexicon values\\n #total subjectivity score from word polarities, total objectivity score, number of subjective words, number of objective words, e\\n sub_score = 0.0\\n obj_score = 0.0\\n nrof_subwords = 0\\n nrof_objwords = 0\\n for word in sentimentvalues.keys():\\n if sentimentvalues[word][0]>0:\\n sub_score = sub_score + sentimentvalues[word][0]\\n nrof_subwords = nrof_subwords + 1\\n if sentimentvalues[word][1]>0:\\n sub_score = sub_score + sentimentvalues[word][1]\\n nrof_subwords = nrof_subwords + 1\\n if sentimentvalues[word][2]>0:\\n obj_score = obj_score + sentimentvalues[word][2]\\n nrof_objwords = nrof_objwords + 1\\n if sub_score>0:\\n additional_freq[\\\"sub_score\\\"] = sub_score+1.0\\n if obj_score>0:\\n additional_freq[\\\"obj_score\\\"] = obj_score+1.0\\n if nrof_subwords>0:\\n additional_freq[\\\"subjective_words\\\"] = nrof_subwords*1.0\\n if nrof_objwords>0:\\n additional_freq[\\\"objective_words\\\"] = nrof_objwords*1.0\\n \\n #Concatenate the dicts\\n features= dict(pos_tag_freq.items() + additional_freq.items())\\n \\n return features\",\n \"def corpus_statistics(corpus, d_corp):\\n print('There are {} types of a total of {} tokens in the corpus.\\\\n' .format(number_types(corpus), corpus_length(corpus)))\\n print('There average token length is {}.\\\\n' .format(average_length(corpus)))\\n print('The longest token is {}.\\\\n' .format(longest_token(corpus)))\\n print('The number of hapaxes is {} and represents the {} of the corpus.\\\\n.' .format(hapaxes(corpus), percentage(hapaxes(corpus), corpus_length(corpus))))\\n print('The 10 most frequent types of the total tokens are {} and represent the {}%.\\\\n' .format(most_frequent(corpus), percentage_common_types(corpus))) \\n print('The hapaxes present in each of the 9 partitions are {}.\\\\n' .format(hapaxes_parts(d_corp)))\\n print('The percentage of hapaxes for each partition is {}.\\\\n' .format(percentage_hapaxes(d_corp, corpus)))\\n plots(d_corp, corpus)\\n print('\\\\nIn the tupla {}, the first element is the number of unique bigrams, and the second element is the percentage of unique bigrams from all the bigrams in the corpus. Similarly, in this tupla {}, the first element is the number of unique trigrams, and the second element is the percentage of unique trigrams from all the bigrams in the corpus.' .format(ngram(corpus, 2), ngram(corpus, 3)))\",\n \"def analyse(self):\\n logging.info(\\\"transferring text to CorpusCook...\\\")\\n\\n paragraphs = self.text.split('\\\\n\\\\n')\\n print(\\\"mean length of splitted lines\\\", (mean([len(p) for p in paragraphs])))\\n\\n # If TIKA resolved '\\\\n'\\n if (mean([len(p) for p in paragraphs])) > 80:\\n paragraphs = [re.sub(r\\\"- *\\\\n\\\", '', p) for p in paragraphs]\\n paragraphs = [p.replace('\\\\n', \\\" \\\") for p in paragraphs]\\n paragraphs = [p.replace(';', \\\" \\\") for p in paragraphs]\\n joiner = \\\" \\\"\\n else:\\n # If TIKA did not\\n joiner = \\\" \\\"\\n\\n processed_text = joiner.join([p\\n for p in paragraphs\\n if\\n p and\\n ks_2samp(self.normal_data, list(p)).pvalue > self.threshold\\n ]\\n )\\n\\n return processed_text.strip()[:self.length_limit]\",\n \"def _count_word_frequency(self, data):\\n _dict = {}\\n for _docs in data:\\n for _word in _docs:\\n if _word in _dict:\\n _dict[_word] += 1\\n else:\\n _dict[_word] = 1\\n return _dict\",\n \"def train():\\n\\tA = collections.defaultdict(dict)\\n\\tB = collections.defaultdict(dict)\\n\\tpos_list = []\\n\\tword_list = []\\n\\tstr_buf = []\\n\\n\\n\\t# read each line and count A and B\\n\\tfor line in sys.stdin:\\n\\t\\tline = line.split()\\n\\t\\t# print(line)\\n\\t\\tif len(line) == 3:\\n\\t\\t\\tstr_buf.append((str(line[0]), str(line[1])))\\n\\t\\t\\tword_list.append(str(line[0]))\\n\\t\\t\\tpos_list.append(str(line[1]))\\n\\n\\t\\telse:\\n\\t\\t\\t# if come to the end of a sentence\\n\\t\\t\\tif len(str_buf) != 0:\\n\\t\\t\\t\\tstr_buf = [('<s>','BOS')] + str_buf + [('</s>', 'EOS')]\\n\\t\\t\\t\\tword_list += ['<s>', '</s>']\\n\\t\\t\\t\\tpos_list += ['BOS', 'EOS']\\n\\n\\t\\t\\t\\tfor i, s in enumerate(str_buf):\\n\\t\\t\\t\\t\\tif s[0] in B[s[1]]:\\n\\t\\t\\t\\t\\t\\tB[s[1]][s[0]] += 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tB[s[1]][s[0]] = 1\\n\\n\\t\\t\\t\\t\\tif s[0] != '</s>':\\n\\t\\t\\t\\t\\t\\t# print('strbuf[i]:',str_buf[i], 's[1]', s[1])\\n\\t\\t\\t\\t\\t\\tif str_buf[i+1][1] in A[s[1]]:\\n\\t\\t\\t\\t\\t\\t\\tA[s[1]][str_buf[i+1][1]] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tA[s[1]][str_buf[i+1][1]] = 1\\n\\n\\t\\t\\t\\tstr_buf = []\\n\\n\\t# get unique POS list and word list\\n\\tpos_list_uniq = list(set(pos_list))\\n\\tword_list_uniq = list(set(word_list))\\n\\n\\n\\t# assume <UNK>, smoothing, normalize\\n\\tB_sm = collections.defaultdict(dict)\\n\\tA_sm = A.copy()\\n\\n\\t# assume words apeear less than 2 times as <UNK>\\n\\tword_count = collections.Counter(word_list)\\n\\tfor pos in B:\\n\\t\\tfor word in B[pos]:\\n\\t\\t\\tif word_count[word] > 1:\\n\\t\\t\\t\\tB_sm[pos][word] = B[pos][word]\\n\\n\\t\\t\\telse: # add <UNK> to B_sm\\n\\t\\t\\t\\tword_list_uniq.remove(word)\\n\\t\\t\\t\\tif '<UNK>' in B_sm[pos]:\\n\\t\\t\\t\\t\\tB_sm[pos]['<UNK>'] += 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tB_sm[pos]['<UNK>'] = 1\\n\\n\\tword_list_uniq += ['<UNK>']\\n\\n\\t# add 1 smoothing\\n\\tfor pos in pos_list_uniq:\\n\\t\\tfor word in word_list_uniq:\\n\\t\\t\\tif word in B_sm[pos]:\\n\\t\\t\\t\\tB_sm[pos][word] += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tB_sm[pos][word] = 1\\n\\n\\tfor prev in pos_list_uniq:\\n\\t\\tfor next in pos_list_uniq:\\n\\t\\t\\tif next in A_sm[prev]:\\n\\t\\t\\t\\tA_sm[prev][next] += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tA_sm[prev][next] = 1\\n\\n\\t# delete instances like A[VB][BOS], A[EOS][VB],\\n\\t# B[VB]['</s>'], B[EOS]['Jack']\\n\\n\\tfor pos in B_sm:\\n\\t\\tfor word in B_sm[pos]:\\n\\t\\t\\tif (pos == 'BOS' and word != '<s>') or \\\\\\n\\t\\t\\t(pos == 'EOS' and word != '</s>') or \\\\\\n\\t\\t\\t(word == '<s>' and pos != 'BOS') or \\\\\\n\\t\\t\\t(word == '</s>' and pos != 'EOS'):\\n\\t\\t\\t\\tB_sm[pos][word] = 0\\n\\n\\tfor prev in A_sm:\\n\\t\\tfor next in A_sm[prev]:\\n\\t\\t\\tif prev == 'EOS' or next == 'BOS':\\n\\t\\t\\t\\tA_sm[prev][next] = 0\\n\\n\\t# normalize\\n\\tfor pos in B_sm:\\n\\t\\ts = sum(B_sm[pos].values())\\n\\t\\tfor word in B_sm[pos]:\\n\\t\\t\\tif B_sm[pos][word] != 0:\\n\\t\\t\\t\\tB_sm[pos][word] /= s\\n\\n\\tfor prev in A_sm:\\n\\t\\ts = sum(A_sm[prev].values())\\n\\t\\tfor next in A_sm[prev]:\\n\\t\\t\\tif A_sm[prev][next] != 0:\\n\\t\\t\\t\\tA_sm[prev][next] /= s\\n\\n\\treturn A_sm, B_sm, word_list_uniq\",\n \"def num_syllables(self, word):\\n # TODO: provide an implementation!\\n word = word.lower()\\n D = self._pronunciations\\n #D = nltk.corpus.cmudict.dict()\\n if(word not in D.keys()):\\n #print word not in CMUDictionary\\n return 1\\n\\n #count stores no of syllables for each pronunciation of the word\\n count = []\\n\\n #for each pronunciation\\n for x in D[word]:\\n n = 0\\n #for each syllable\\n for y in x:\\n #if vowel sound\\n if y[-1].isdigit():\\n n = n + 1\\n count.append(n)\\n # return the pronunciation having least syllables\\n return min(count)\\n #return min([len([y for y in x if y[-1].isdigit()]) for x in D[word.lower()]])\",\n \"def get_word_frequency():\\n counter = Counter()\\n with open('resource/word-count.txt', encoding=\\\"utf8\\\") as f:\\n for line in f.readlines():\\n try:\\n word, count = line.split(':')\\n if (word == \\\"RT\\\"):\\n continue\\n count = int(count)\\n counter[word] += count\\n except Exception as e:\\n continue\\n return counter\",\n \"def analyze(self, text):\\n\\n # TODO\\n # tokens = tokenizer.tokenize(tweet)\\n tokenizer = nltk.tokenize.TweetTokenizer()\\n tokens = tokenizer.tokenize(text)\\n score = 0\\n\\n for word in tokens:\\n # iterate over tokens#str.lower\\n\\n if word.lower() in self.positives:\\n score = score+1\\n\\n elif word.lower() in self.negatives:\\n score = score-1\\n\\n else:\\n continue\\n return score\",\n \"def process_text(self, text):\\n\\n flags = (re.UNICODE if sys.version < '3' and type(text) is unicode # noqa: F821\\n else 0)\\n pattern = r\\\"\\\\w[\\\\w']*\\\" if self.min_word_length <= 1 else r\\\"\\\\w[\\\\w']+\\\"\\n regexp = self.regexp if self.regexp is not None else pattern\\n\\n words = re.findall(regexp, text, flags)\\n # remove 's\\n words = [word[:-2] if word.lower().endswith(\\\"'s\\\") else word\\n for word in words]\\n # remove numbers\\n if not self.include_numbers:\\n words = [word for word in words if not word.isdigit()]\\n # remove short words\\n if self.min_word_length:\\n words = [word for word in words if len(word) >= self.min_word_length]\\n\\n stopwords = set([i.lower() for i in self.stopwords])\\n if self.collocations:\\n word_counts = unigrams_and_bigrams(words, stopwords, self.normalize_plurals, self.collocation_threshold)\\n else:\\n # remove stopwords\\n words = [word for word in words if word.lower() not in stopwords]\\n word_counts, _ = process_tokens(words, self.normalize_plurals)\\n\\n return word_counts\",\n \"def all_categories_for_phrase(db, phrase, access_codes):\\n ratings = [0, 0, 0]\\n for access_code in access_codes:\\n category_index = annotator_category_for_phrase(db, phrase, access_code)\\n ratings[category_index] += 1\\n return ratings\",\n \"def sentiment_analysis(self):\\n train_pos = pd.read_csv(\\\"data/train_Arabic_tweets_positive_20190413.tsv\\\", sep='\\\\t', names=[\\\"label\\\", \\\"tweet\\\"])\\n train_neg = pd.read_csv(\\\"data/train_Arabic_tweets_negative_20190413.tsv\\\", sep='\\\\t', names=[\\\"label\\\", \\\"tweet\\\"])\\n train = pd.concat([train_pos, train_neg])\\n train.tweet = train.tweet.apply(self.preprocessor).apply(tokenization).apply(lambda x: x.tokens[0])\\n le = LabelEncoder()\\n le.fit(train.label)\\n train.label = le.transform(train.label)\\n\\n sentence_inds, vocab, self.num_tokens, word_index, index_word = helper.encode_tokens(train.tweet.values)\\n\\n\\n self.embeddings_matrix = helper.load_embedding_matrix(self.num_tokens, self.embedding_size, \\n word_index, self.embeddings_index)\\n\\n\\n train_padded = pad_sequences(sentence_inds, padding=\\\"post\\\", truncating=\\\"post\\\", maxlen=100)\\n\\n self.X_train, self.X_valid, self.y_train, self.y_valid = train_test_split(train_padded, train.label.values, test_size=0.5,random_state=0, stratify=train.label.values)\\n\\n model = self.train_model()\\n y_pred = model.predict(self.X_valid)\\n return (np.argmax(y_pred, axis=1) == self.y_valid).sum() / self.y_valid.shape[0]\",\n \"def get_data(articles): # Here, the articles will be very long strings\\r\\n vdictionary = {} # dictionary for tokens that are found in dictionary\\r\\n _odata = [0] * 12 # list collecting everything except date; last number of words=index:0\\r\\n word_length = 0 # initializing the value of word length; will be updated via loop\\r\\n tokens = re.findall('\\\\w+', articles) # Note that \\\\w+ splits hyphenated words\\r\\n for token in tokens: # Goes through generated tokens from articles\\r\\n if (not token.isdigit()) and (len(token) > 1) and (token in lm_dictionary.keys()): # conditions for checking if token is in dictionary\\r\\n _odata[1] += 1 # updating word count \\r\\n word_length += len(token) # updating word length\\r\\n if token not in vdictionary: # initial statement regarding steps for handling tokens not in the dictionary\\r\\n vdictionary[token] = 1 # count of tokens in text that show up in dictionary\\r\\n \\r\\n####### Keeping Track of Categorical Token Counts (Nonzero entry=True) also checks if word is stop word\\r\\n if lm_dictionary[token].positive and not lm_dictionary[token].stopword: _odata[2] += 1\\r\\n if lm_dictionary[token].negative and not lm_dictionary[token].stopword: _odata[3] += 1\\r\\n if lm_dictionary[token].uncertainty and not lm_dictionary[token].stopword: _odata[4] += 1\\r\\n if lm_dictionary[token].litigious and not lm_dictionary[token].stopword: _odata[5] += 1\\r\\n if lm_dictionary[token].weak_modal and not lm_dictionary[token].stopword: _odata[6] += 1\\r\\n if lm_dictionary[token].moderate_modal and not lm_dictionary[token].stopword: _odata[7] += 1\\r\\n if lm_dictionary[token].strong_modal and not lm_dictionary[token].stopword: _odata[8] += 1\\r\\n if lm_dictionary[token].constraining and not lm_dictionary[token].stopword: _odata[9] += 1\\r\\n #total_syllables += lm_dictionary[token].syllables # interesting parameter to measure\\r\\n\\r\\n #_odata[12] = len(re.findall('[0-9]', doc))\\r\\n # drop punctuation within numbers for number count\\r\\n articles = re.sub('(?!=[0-9])(\\\\.|,)(?=[0-9])', '', articles)\\r\\n articles = articles.translate(str.maketrans(string.punctuation, \\\" \\\" * len(string.punctuation)))\\r\\n #_odata[13] = len(re.findall(r'\\\\b[-+\\\\(]?[$€£]?[-+(]?\\\\d+\\\\)?\\\\b', doc))\\r\\n # _odata[14] = total_syllables / _odata[2]\\r\\n #print(_odata[1])\\r\\n _odata[10] = word_length / _odata[1] # computing average word length\\r\\n _odata[11] = len(vdictionary) # total vocab count\\r\\n \\r\\n # Convert counts to %\\r\\n for i in range(2, 9 + 1): # specifying range of percentages\\r\\n try:\\r\\n _odata[i] = (_odata[i] / _odata[1]) * 100 # updating count to percent\\r\\n except:\\r\\n print(\\\"zero denominator\\\")\\r\\n # Vocabulary\\r\\n \\r\\n return _odata # returning the data\\r\",\n \"def computeWordsFrequencies(self):\\n token_stream = self._tokenize(self.readable)\\n token_map = self._countTokens(token_stream)\\n # print token_map.items()\\n return sorted(token_map.items(), key = lambda x : x[1], reverse = True)\",\n \"def analyze(self, text):\\n\\n sent = 0\\n for word in text.split():\\n # check each word in tweet\\n if word.strip(\\\":, \\\").lower() in self.posWords:\\n sent += 1\\n elif word.strip(\\\":, \\\").lower() in self.negWords:\\n sent -= 1\\n\\n return sent\",\n \"def analyze_emoji_sentimens(text):\\n sum = 0.0\\n count = 0\\n for character in list(text):\\n value = index.get(character, None)\\n if value != None:\\n sum += value\\n count += 1\\n if count == 0:\\n return 0.0\\n\\n return sum/count\",\n \"def sentiment_analyzer(text):\\n\\n\\tlower_text = text.lower()\\n\\t\\t\\n\\thashtag_scaling = 0.3\\n\\texclamation_scaling = 0.5\\n\\tuppercase_scaling = 0.2\\n\\n\\n\\tsent_index = 0\\n\\n\\tfor x in range(len(positive_words)):\\n\\t\\tsent_index += lower_text.count(positive_words[x])\\n\\tfor x in range(len(negative_words)):\\n\\t\\tsent_index -= lower_text.count(negative_words[x])\\n\\tif '!' in text:\\n\\t\\tsent_index *= exclamation_scaling * lower_text.count('!') + 1\\n\\tif '#' in text:\\n\\t\\tsent_index *= hashtag_scaling * lower_text.count('#') + 1\\n\\tsent_index *= uppercase_scaling * sum(1 for c in text if c.isupper())\\n\\t\\t\\n\\treturn sent_index\",\n \"def get_corpus_counts(x,y,label):\\n raise NotImplementedError\",\n \"def read_gulordava_corpus(corpus_dir: str) -> dict:\\n def _read_file(path: str) -> List[str]:\\n with open(path, \\\"r\\\") as f:\\n return f.readlines()\\n\\n sentences = _read_file(f\\\"{corpus_dir}/generated.text\\\")\\n sentence_info = _read_file(f\\\"{corpus_dir}/generated.tab\\\")[1:] # Skip header line\\n labelled_corpus = {}\\n\\n for i, sentence in enumerate(sentences):\\n right_info, wrong_info = sentence_info[2*i], sentence_info[2*i+1]\\n\\n # Parse lines\\n right_info, wrong_info = right_info.split(\\\"\\\\t\\\"), wrong_info.split(\\\"\\\\t\\\")\\n constr_id, sent_id, correct_number, right_form, class_, type_ = right_info[1:7]\\n len_context, len_prefix, sent = right_info[11:14]\\n constr_id_wrong, sent_id_wrong, _, wrong_form, class_wrong, type_wrong = wrong_info[1:7]\\n sent_wrong = wrong_info[13]\\n\\n assert class_ == \\\"correct\\\" and class_wrong == \\\"wrong\\\"\\n assert constr_id == constr_id_wrong and sent_id == sent_id_wrong and sent == sent_wrong and type_ == type_wrong\\n\\n len_prefix, len_context = int(len_prefix), int(len_context)\\n subj_pos = len_prefix - len_context\\n verb_pos = len_prefix\\n sentence = sent.split()\\n\\n misc_info = {\\n \\\"raw\\\": sent,\\n \\\"subj_pos\\\": subj_pos,\\n \\\"verb_pos\\\": verb_pos,\\n \\\"right_form\\\": right_form,\\n \\\"wrong_form\\\": wrong_form,\\n \\\"correct_number\\\": correct_number,\\n \\\"sent_id\\\": sent_id,\\n \\\"constr_id\\\": constr_id,\\n \\\"type\\\": type_\\n }\\n\\n labelled_sentence = {\\n \\\"sen\\\": sentence, \\\"labels\\\": [0 if correct_number == \\\"sing\\\" else 1] * len(sentence), **misc_info\\n }\\n labelled_corpus[i] = labelled_sentence\\n\\n return labelled_corpus\",\n \"def word_count():\\n word_counter = Counter()\\n\\n # read files and count words\\n for file_path in Path(INPUTS_PATH).rglob(\\\"*\\\"):\\n if file_path.is_file():\\n print(f\\\"Processing input file: {file_path.as_posix()}\\\")\\n word_counter += Counter(file_path.read_text().split())\\n\\n # write the result to OUTPUTS_PATH\\n output_file = Path(OUTPUTS_PATH) / \\\"output.txt\\\"\\n with output_file.open(\\\"w\\\") as f:\\n for word, count in word_counter.most_common():\\n f.write(f\\\"{word}: {count}\\\\n\\\")\\n print(f\\\"Generated output file: {output_file.as_posix()}\\\")\",\n \"def load_input(path):\\n counts = defaultdict(int)\\n if not os.path.exists(mode+'indices.p'):\\n root = '/'.join(path.split('/')[0:-1])\\n all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\\n else:\\n all_paths = [path]\\n \\n for path in all_paths:\\n print(path)\\n with open(path) as f:\\n if mode == 'word':\\n words = tokenize(f.read())\\n else:\\n words = f.read()\\n\\n for word in words:\\n counts[word] += 1 \\n\\n words = [x for x in words if len(x) > 0]\\n return words, counts\",\n \"def analyze_reviews(reviews):\\n\\n good_reviews=reviews[reviews['rs_review_movie_score']>=9]\\n bad_reviews=reviews[reviews['rs_review_movie_score']<=2]\\n\\n print 'len(good_reviews)=%s' % len(good_reviews)\\n print 'len(bad_reviews)=%s' % len(bad_reviews)\\n\\n m = re.compile('\\\\d')\\n\\n english_stop_words=stopwords.words('english')\\n\\n\\n def tokenize(text):\\n tokens=nltk.word_tokenize(text)\\n # strip out trailing puncutation\\n tokens = [ token[:-1] if token[-1] in ['.',',','!','?'] else token for token in tokens]\\n\\n # lower case\\n tokens = [token.lower() for token in tokens]\\n\\n # Take only relativly long characters\\n tokens = [token for token in tokens if len(token)>=3]\\n\\n # remove words with numbers/digits\\n tokens = [token for token in tokens if m.search(token) is None]\\n\\n # Remove stop words: http://nltk.googlecode.com/svn/trunk/doc/book/ch02.html\\n tokens = [token for token in tokens if token not in english_stop_words]\\n return tokens\\n\\n good_tokens_list = []\\n for i,review in good_reviews.iterrows():\\n text=review['rs_review_text']\\n good_tokens_list.append(tokenize(text))\\n\\n bad_tokens_list = []\\n for i,review in bad_reviews.iterrows():\\n text=review['rs_review_text']\\n bad_tokens_list.append(tokenize(text))\\n\\n all_words=Counter()\\n for tokens in good_tokens_list + bad_tokens_list:\\n for token in tokens:\\n all_words[token]+=1\\n\\n most_common=all_words.most_common(2000)\\n most_common=zip(*most_common)[0]\\n\\n print 'most_common_words = ',most_common[-20:]\\n\\n def document_features(tokens):\\n return {word:word in tokens for word in most_common}\\n\\n good_set=[(document_features(tokens), 'pos') for tokens in good_tokens_list]\\n bad_set=[(document_features(tokens), 'neg') for tokens in bad_tokens_list]\\n\\n train_set = good_set + bad_set\\n random.shuffle(train_set) # dunno if this is necessary\\n\\n classifier = nltk.NaiveBayesClassifier.train(train_set)\\n\\n print 'accuracy',nltk.classify.accuracy(classifier, train_set)\\n\\n classifier.show_most_informative_features(300)\\n\\n return classifier\",\n \"def structure_anslysis(text, display = None):\\n st.write('Text Size Exceeded! Truncating...')\\n doc = nlp(text[:100000])\\n pos_freq = pos_tag_counts(doc)\\n ent_freq = entity_counts(doc)\\n \\n fig, axs = plt.subplots(1, 2, figsize = (15, 6))\\n \\n sns.barplot(list(pos_freq.keys()), list(pos_freq.values()), color='#e84118', ax = axs[0])\\n axs[0].set_title('POS COUNTS')\\n axs[0].set_xticklabels(labels = list(pos_freq.keys()), rotation = 90)\\n \\n sns.barplot(list(ent_freq.keys()), list(ent_freq.values()), color='#273c75', ax = axs[1])\\n axs[1].set_title('ENTITY COUNTS')\\n axs[1].set_xticklabels(labels = list(ent_freq.keys()), rotation = 90) \\n \\n plt.show()\\n \\n if display:\\n spacy_streamlit.visualize_ner(doc, labels = nlp.get_pipe('ner').labels)\\n \\n \\n return pos_freq, ent_freq\",\n \"def add_unique_word_count(self):\\n call_count = lambda letter_: self._count_unique_words(letter_)\\n self.dataframe['unique_words'] = self.dataframe['letter'].map(call_count)\",\n \"def measure(colloc_tag, colloc_count, n1grams, unigrams, n):\\r\\n collocation_words, collocation_tags = colloc_tag.split('/')\\r\\n collocation_words = collocation_words.split(' ')\\r\\n collocation_tags = collocation_tags.split(' ')\\r\\n pattern_words = ' '.join(collocation_words[:-1])\\r\\n pattern_tags = ' '.join(collocation_tags[:-1])\\r\\n\\r\\n pattern = pattern_words + '/' + pattern_tags\\r\\n last_word = collocation_words[-1] + '/' + collocation_tags[-1]\\r\\n c_pattern = int(n1grams[pattern])\\r\\n c_lw = int(unigrams[last_word])\\r\\n colloc_count = int(colloc_count)\\r\\n\\r\\n tsc = t_score(colloc_count, c_pattern, c_lw, n)\\r\\n pmisc = pmi(colloc_count, c_pattern, c_lw, n)\\r\\n logdsc = logDice(colloc_count, c_pattern, c_lw)\\r\\n return logdsc, pmisc, tsc\",\n \"def gather_counts(directory):\\n counts_un = defaultdict(int)\\n counts_bi = defaultdict(int)\\n counts_tri = defaultdict(int)\\n prev_prev = \\\"<s>\\\"\\n prev = \\\"<s>\\\"\\n for filename in os.listdir(f\\\"./{directory}\\\"):\\n if \\\".DS_Store\\\" in filename:\\n continue\\n with open(f\\\"./{directory}/{filename}\\\", \\\"r\\\") as f:\\n for line in f:\\n line = line.strip()\\n if len(line) == 0:\\n continue\\n counts_un[line+\\\"\\\\n\\\"] += 1\\n counts_bi[prev+\\\"\\\\n\\\"+line+\\\"\\\\n\\\"] += 1\\n counts_tri[prev_prev+\\\"\\\\n\\\"+prev+\\\"\\\\n\\\"+line+\\\"\\\\n\\\"] += 1\\n prev_prev = prev\\n prev = line\\n counts_un[\\\"</s>\\\\n\\\"] += 2\\n counts_bi[\\\"</s>\\\\n</s>\\\\n\\\"] += 1\\n counts_bi[prev+\\\"\\\\n\\\"+\\\"</s>\\\\n\\\"] += 1\\n counts_tri[prev_prev+\\\"\\\\n\\\"+prev+\\\"\\\\n\\\" + \\\"</s>\\\\n\\\"] += 1\\n counts_tri[prev+\\\"\\\\n</s>\\\\n</s>\\\\n\\\"] += 1\\n return counts_un, counts_bi, counts_tri\",\n \"def preprocessing(raw_text_df):\\r\\n \\r\\n stemmer = nltk.stem.porter.PorterStemmer()\\r\\n tokenizer = RegexpTokenizer(r'\\\\w+')\\r\\n # iterate over all lines for preprocessing\\r\\n for index, line in enumerate(raw_text_df):\\r\\n \\r\\n # if there is mention of stars from 1-5, change the integer into\\r\\n # text and combine the number and the word \\\"star\\\" to make a new word\\r\\n # example: \\\"I give this product 1 star\\\" is now \\\"I give this product onestar\\\"\\r\\n # why? numbers are removed as part of preprocessing\\r\\n if \\\"1 star\\\" in line:\\r\\n line = line.replace(\\\"1 star\\\", \\\"onestar\\\")\\r\\n if \\\"1 stars\\\" in line:\\r\\n line = line.replace(\\\"1 stars\\\", \\\"onestar\\\")\\r\\n if \\\"2 star\\\" in line:\\r\\n line = line.replace(\\\"2 star\\\", \\\"twostars\\\")\\r\\n if \\\"2 stars\\\" in line:\\r\\n line = line.replace(\\\"2 stars\\\", \\\"twostars\\\")\\r\\n if \\\"3 star\\\" in line:\\r\\n line = line.replace(\\\"3 star\\\", \\\"threestars\\\")\\r\\n if \\\"3 stars\\\" in line:\\r\\n line = line.replace(\\\"3 stars\\\", \\\"threestars\\\")\\r\\n if \\\"4 star\\\" in line:\\r\\n line = line.replace(\\\"4 star\\\", \\\"fourstars\\\")\\r\\n if \\\"4 stars\\\" in line:\\r\\n line = line.replace(\\\"4 stars\\\", \\\"fourstars\\\")\\r\\n if \\\"5 star\\\" in line:\\r\\n line = line.replace(\\\"5 star\\\", \\\"fivestars\\\")\\r\\n if \\\"5 stars\\\" in line:\\r\\n line = line.replace(\\\"5 stars\\\", \\\"fivestars\\\")\\r\\n \\r\\n # tokenize lines\\r\\n tokens = re.split('(\\\\d+)',line)\\r\\n # remove numbers\\r\\n no_digits = [w for w in tokens if not w.isdigit()]\\r\\n # join tokens\\r\\n joined_text = \\\" \\\".join(no_digits)\\r\\n # re tokenize\\r\\n tokens = tokenizer.tokenize(joined_text)\\r\\n # make tokens lowercase\\r\\n lower_tokens = [w.lower() for w in tokens if type(w) == str] \\r\\n # remove stopwords\\r\\n stopped_tokens = [w for w in lower_tokens if not w in stopwords.words('english')]\\r\\n # stem words\\r\\n clean_tokens = [stemmer.stem(w) for w in stopped_tokens]\\r\\n # join text\\r\\n joined_text = \\\" \\\".join(clean_tokens)\\r\\n # replace line with preprocessed line\\r\\n raw_text_df[index] = joined_text\\r\\n print(index)\",\n \"def calculate_word_counts(text : Text)->Counter:\\n return Counter(tokenized_text(text))\",\n \"def get_all_words(annotation_files):\\n all_words = np.array([])\\n for annotation_file in annotation_files:\\n annotations = []\\n with open(annotation_file, 'r', encoding='utf-8') as f:\\n lines = f.readlines()\\n for line in lines:\\n line = line.strip().rstrip('\\\\n').lstrip('\\\\ufeff').strip().split(',', maxsplit=8)\\n if str(line[-1]).strip() != \\\"\\\" and str(line[-1]).strip() is not None:\\n annotations.append(str(line[-1]).strip())\\n annotations = np.array(annotations)\\n all_words = np.concatenate((all_words, annotations), axis=0)\\n unique_words = list(set(all_words))\\n print(\\\"Get_All_Words::All words num / Unique words num is {0}/{1}\\\".format(len(all_words), len(unique_words)))\\n return all_words, unique_words\",\n \"def convert_word_to_count(counter={}, doc=[]):\\n for sentence in doc:\\n for word in sentence.split():\\n if word not in counter:\\n counter[word] = 1\\n else:\\n counter[word] += 1\\n return counter\",\n \"def wordFreq(parseThis):\\n \\n freq = {}\\n nono = ('\\\"', \\\"'\\\", '%', '$', '!', '.', '?', '-', ','\\n , '\\\\n', '\\\\t', '\\\\r', ':', ';')\\n\\n for c in nono:\\n parseThis = parseThis.replace(c, \\\" \\\")\\n \\n words = parseThis.split()\\n \\n for word in words:\\n temp = word.lower()\\n freq[temp] = freq.get(temp, 0) + 1\\n\\n return freq\",\n \"def basic_statistics_of_email(data):\\n word_counts = []\\n character_count = 0\\n\\n for ind, row in data.iterrows():\\n tokenizer = RegexpTokenizer(r'\\\\w+')\\n real_words = tokenizer.tokenize(row[\\\"RawText\\\"].lower())\\n\\n character_count += sum(map(len, real_words))\\n word_counts.append(len(real_words))\\n\\n return character_count, pd.Series(word_counts)\",\n \"def train_ngrams(dataset):\\n trigram_counts = dict()\\n bigram_counts = dict()\\n unigram_counts = dict()\\n token_count = 0\\n\\n ### YOUR CODE HERE\\n def enterDic(phrase, dict):\\n if phrase in dict:\\n dict[phrase] += 1\\n else:\\n dict[phrase] = 1\\n\\n unigram_counts[word_to_num['UUUNKKK']] = 0\\n\\n for sentence in dataset:\\n enterDic(sentence[1], unigram_counts) # count number of start of sentences\\n enterDic((sentence[0], sentence[1]), bigram_counts) # count number of start of sentences\\n token_count += 2\\n for i in range(2, len(sentence)):\\n token_count += 1\\n enterDic(sentence[i], unigram_counts)\\n enterDic((sentence[i - 1], sentence[i]), bigram_counts)\\n enterDic((sentence[i - 2], sentence[i - 1], sentence[i]), trigram_counts)\\n ### END YOUR CODE\\n return trigram_counts, bigram_counts, unigram_counts, token_count\",\n \"def train(self, corpus): \\n for sentence in corpus.corpus: # iterate over sentences in the corpus\\n for token in sentence: # iterate over datums in the sentence\\n self.unigrams[token] += 1\\n self.total += 1\\n V = len(self.unigrams) # vocabulary size \\n for ug,count in self.unigrams.iteritems():\\n \\tself.f1[ug] = math.log10(count+1) - math.log10(self.total + V)\",\n \"def get_num_words_spoken_by_character_per_episode(content):\\n content = list(csv.reader(content.splitlines(), delimiter=','))\\n characters = [name[2] for name in content]\\n characters = list(dict.fromkeys(characters))\\n del characters[0]\\n res = defaultdict()\\n for character in characters:\\n episode = 1\\n dic = {}\\n count = 0\\n for row in content: \\n if row[2] == character:\\n if str(episode) == row[1]:\\n count += len(row[3].split())\\n else:\\n dic[str(episode)] = count\\n episode = int(row[1])\\n count = len(row[3].split())\\n if '13' not in dic.keys():\\n dic['13'] = count \\n dic = Counter(dic)\\n res[character] = dic\\n return res\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6335053","0.57268775","0.57179636","0.5714977","0.57052946","0.5632471","0.56277466","0.56243765","0.5612738","0.5593558","0.55885386","0.5571546","0.5560268","0.55578226","0.55549335","0.55408674","0.55253506","0.5510573","0.55039716","0.5502862","0.5502827","0.5487121","0.5435187","0.5422129","0.53818375","0.5378401","0.53673434","0.5360341","0.53580433","0.53432876","0.5335175","0.5329313","0.53272194","0.5311351","0.53058684","0.5282008","0.52775645","0.52738386","0.5271024","0.52704257","0.5264546","0.52574384","0.52499396","0.5244697","0.5239421","0.52232456","0.5214361","0.5210121","0.52069247","0.51841426","0.5178881","0.51779014","0.5174941","0.51709265","0.5166267","0.51652825","0.5165065","0.51609915","0.51502705","0.51382136","0.51336014","0.5123653","0.511272","0.5107917","0.5100428","0.51002264","0.51001096","0.5098017","0.50958323","0.5095243","0.508407","0.5081947","0.5073839","0.50737953","0.507253","0.5071211","0.50669014","0.5065129","0.506511","0.5061986","0.50545025","0.50448054","0.5042495","0.5034689","0.5033884","0.5026838","0.50244224","0.5024383","0.5015165","0.50118285","0.5010954","0.50091964","0.50089985","0.5008505","0.50070006","0.5002425","0.5002252","0.4994001","0.4991696","0.49900976"],"string":"[\n \"0.6335053\",\n \"0.57268775\",\n \"0.57179636\",\n \"0.5714977\",\n \"0.57052946\",\n \"0.5632471\",\n \"0.56277466\",\n \"0.56243765\",\n \"0.5612738\",\n \"0.5593558\",\n \"0.55885386\",\n \"0.5571546\",\n \"0.5560268\",\n \"0.55578226\",\n \"0.55549335\",\n \"0.55408674\",\n \"0.55253506\",\n \"0.5510573\",\n \"0.55039716\",\n \"0.5502862\",\n \"0.5502827\",\n \"0.5487121\",\n \"0.5435187\",\n \"0.5422129\",\n \"0.53818375\",\n \"0.5378401\",\n \"0.53673434\",\n \"0.5360341\",\n \"0.53580433\",\n \"0.53432876\",\n \"0.5335175\",\n \"0.5329313\",\n \"0.53272194\",\n \"0.5311351\",\n \"0.53058684\",\n \"0.5282008\",\n \"0.52775645\",\n \"0.52738386\",\n \"0.5271024\",\n \"0.52704257\",\n \"0.5264546\",\n \"0.52574384\",\n \"0.52499396\",\n \"0.5244697\",\n \"0.5239421\",\n \"0.52232456\",\n \"0.5214361\",\n \"0.5210121\",\n \"0.52069247\",\n \"0.51841426\",\n \"0.5178881\",\n \"0.51779014\",\n \"0.5174941\",\n \"0.51709265\",\n \"0.5166267\",\n \"0.51652825\",\n \"0.5165065\",\n \"0.51609915\",\n \"0.51502705\",\n \"0.51382136\",\n \"0.51336014\",\n \"0.5123653\",\n \"0.511272\",\n \"0.5107917\",\n \"0.5100428\",\n \"0.51002264\",\n \"0.51001096\",\n \"0.5098017\",\n \"0.50958323\",\n \"0.5095243\",\n \"0.508407\",\n \"0.5081947\",\n \"0.5073839\",\n \"0.50737953\",\n \"0.507253\",\n \"0.5071211\",\n \"0.50669014\",\n \"0.5065129\",\n \"0.506511\",\n \"0.5061986\",\n \"0.50545025\",\n \"0.50448054\",\n \"0.5042495\",\n \"0.5034689\",\n \"0.5033884\",\n \"0.5026838\",\n \"0.50244224\",\n \"0.5024383\",\n \"0.5015165\",\n \"0.50118285\",\n \"0.5010954\",\n \"0.50091964\",\n \"0.50089985\",\n \"0.5008505\",\n \"0.50070006\",\n \"0.5002425\",\n \"0.5002252\",\n \"0.4994001\",\n \"0.4991696\",\n \"0.49900976\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65279776"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3195,"cells":{"query":{"kind":"string","value":"Update the total occurrence counts of each unigram, bigram, and trigram"},"document":{"kind":"string","value":"def update_syllable_count(word, syll_count):\n\n syllables = word.split('-')\n for i in range(1, 4):\n for j in range(len(syllables) - i + 1):\n gram = '-'.join(syllables[j: j + i])\n count = syll_count.setdefault(gram, 0)\n syll_count[gram] = count + 1"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _count(self):\n words = [word.lower() for word in self.corpus.words()]\n bigrams_words = bigrams(words)\n for bigram in bigrams_words:\n self._bigrams[bigram] += 1","def count_ngrams(self, corpus):\n \n self.unigramcounts = {} # might want to use defaultdict or Counter instead\n self.bigramcounts = {} \n self.trigramcounts = {} \n\n self.total = 2\n ##Your code here\n\n for sentence in corpus:\n temp_1 = get_ngrams(sentence,1)\n temp_2 = get_ngrams(sentence,2)\n temp_3 = get_ngrams(sentence,3)\n for i in range(len(temp_1)):\n if temp_1[i] in self.unigramcounts:\n self.unigramcounts[temp_1[i]] += 1\n else:\n self.unigramcounts[temp_1[i]] = 1\n self.total += 1\n\n for i in range(len(temp_2)):\n if temp_2[i] in self.bigramcounts:\n self.bigramcounts[temp_2[i]] += 1\n else:\n self.bigramcounts[temp_2[i]] = 1\n\n for i in range(len(temp_3)):\n if temp_3[i] in self.trigramcounts:\n self.trigramcounts[temp_3[i]] += 1\n else:\n self.trigramcounts[temp_3[i]] = 1\n return","def count_ngrams(self, corpus):\n \n self.unigramcounts = defaultdict(int)\n self.bigramcounts = defaultdict(int)\n self.trigramcounts = defaultdict(int)\n\n self.sentence_counts = 0\n self.word_count = 0\n\n for line in corpus:\n sequence = line\n self.sentence_counts +=1\n\n unigrams = get_ngrams(sequence, n=1)\n for gram in unigrams:\n self.word_count += 1\n self.unigramcounts[gram] +=1\n\n bigrams = get_ngrams(sequence, n=2)\n for gram in bigrams:\n self.bigramcounts[gram] +=1\n\n trigrams = get_ngrams(sequence, n=3)\n for gram in trigrams:\n self.trigramcounts[gram] +=1\n\n #self.unigramcounts[('START')] = self.sentence_counts *2\n self.bigramcounts[('START', 'START')] = self.sentence_counts\n\n #return self","def count_ngrams(self):\n self.unigram = self.count_unigram(self.word_list)\n self.bigram = self.count_bigram(self.word_list)\n # self.trigram = self.count_trigram(self.word_list)\n # self.four_gram = self.count_four_gram(self.word_list)\n # self.five_gram = self.count_five_gram(self.word_list)","def updateWordCounts():\n emaildata = loadEmailData()\n englishwords = importDictionary()\n countAllWords(emaildata, englishwords)","def train(self, corpus):\n for sentence in corpus.corpus:\n for datum in sentence.data: \n self.unigramCounts[datum.word] += 1\n self.totalCount += 1","def train(self, corpus): \n for sentence in corpus.corpus:\n prev_word = None\n for datum in sentence.data:\n word = datum.word\n self.unigram_count[word] += 1\n if prev_word != None:\n self.bigram_count[prev_word][word] += 1\n prev_word = word\n \n self.vocabulary_size = len(self.unigram_count)\n self.num_words = sum(self.unigram_count.values())","def setCounts(self):\n N=len(self.y)\n self.counts=np.zeros(len(self.y))\n self.idf=np.zeros(len(self.y))\n for i in range(0,len(self.counts)):\n for word in self.qtext:\n wc=self.atext[i].count(word)\n self.counts[i]+=wc\n if wc>0:\n d=0\n for sentence in self.atext:\n if word in sentence:\n d+=1\n self.idf[i]+=wc*np.log(N/d)","def train(self, corpus):\n lastToken = \"#\"\n for sentence in corpus.corpus:\n for datum in sentence.data:\n token = datum.word\n self.reverseBigramCount[token][lastToken] += 1\n self.bigramCount[lastToken][token] += 1\n self.unigramCount[token] += 1\n self.total += 1\n lastToken = token","def get_counts(data):\n\n bigrams = {}\n unigrams = {}\n #range is len-1 because the bigram uses ith+1 element\n data=list(data)\n for i in range(0, len(data)-1):\n #ith element and ith+1 element\n bigram=(data[i],data[i+1])\n if(bigram in bigrams):\n count=bigrams[bigram]\n bigrams[bigram]= count+1\n else:\n #if bigram not in dict of bigrams, add with count 1\n bigrams[bigram]=1\n\n for unigram in data:\n if(unigram in unigrams):\n count=unigrams[unigram]\n unigrams[unigram]= count+1\n else:\n #if unigram not present, add with count 1\n unigrams[unigram]=1\n\n return bigrams,unigrams","def pop_bigrams_old(self, corpus):\n for sentence in corpus.sents():\n for w1, w2 in bigrams(word_tokenize(sentence), pad_right=True, pad_left=True):\n self.bigrams[w1][w2] += 1\n\n # Convert trigrams to probabilities\n for wp in self.bigrams:\n total_count = float(sum(self.bigrams[wp].values()))\n for w2 in self.bigrams[wp]:\n self.bigrams[wp][w2] /= total_count","def count_ngrams(self, corpus):\n self.unigramcounts = defaultdict(int) # might want to use defaultdict or Counter instead\n self.bigramcounts = defaultdict(int)\n self.trigramcounts = defaultdict(int)\n\n self.total_word_count = 0\n self.total_sentence_count = 0\n\n # For each sentence, generate ngram_counts\n for sentence in corpus :\n # 2 extra START tokens and 1 extra STOP token\n self.total_word_count += len(sentence) + 3\n self.total_sentence_count += 1\n for unigram in get_ngrams(sentence, 1) :\n self.unigramcounts[unigram] += 1\n for bigram in get_ngrams(sentence, 2) :\n self.bigramcounts[bigram] += 1\n for trigram in get_ngrams(sentence, 3) :\n self.trigramcounts[trigram] += 1\n\n return","def calcCountDict(TFdict):\n\n countDict = {}\n\n for doc in TFdict:\n for term in doc:\n if term in countDict:\n countDict[term] +=1\n else:\n countDict[term] = 1\n\n return countDict","def update_frequencies():\n pass","def update(self, iterable):\n for word in iterable:\n if word in self:\n self[word] = self[word] + 1\n self.tokens += 1\n else:\n self[word] = 1\n self.types += 1\n self.tokens += 1","def _count_word_frequency(self, data):\n _dict = {}\n for _docs in data:\n for _word in _docs:\n if _word in _dict:\n _dict[_word] += 1\n else:\n _dict[_word] = 1\n return _dict","def _collect_counts(self, instance_list):\n \"\"\" Based on each instance, I augment empirical counts for every word and its BIO label in feature_count_table and for every transition from previous label to current label in transition_count_table.\n All \"rare words\" (those words that appear less than 3 times) are replaced by <UNK>.\n I also add label|START counts.\n \"\"\"\n # Build feature_count_table of V x labels and transition_count_table of labels x labels\n for instance in instance_list: # Set of <(w, pos), l>\n index = 0\n for t in instance.data: # Tuple of (w, pos)\n index = instance.data.index(t)\n # print t[0] # word\n # print instance.label[index] # label\n if t in self.V:\n self.feature_count_table[self.V.index(t)][self.labels.index(instance.label[index])] +=1\n else:\n self.feature_count_table[self.V.index('<UNK>')][self.labels.index(instance.label[index])] +=1\n if index > 0:\n self.transition_count_table[self.labels.index(instance.label[index-1])][self.labels.index(instance.label[index])] += 1\n else:\n self.transition_count_table[len(self.labels)][self.labels.index(instance.label[index])] += 1","def calculate(self, tokens: list):\n vektor_tf_unigram = {}\n\n for token in tokens:\n if token in vektor_tf_unigram:\n vektor_tf_unigram[token] = vektor_tf_unigram[token] + 1\n else:\n vektor_tf_unigram[token] = 1\n\n return vektor_tf_unigram","def print_trigrams_count(self):\n for u_v in self.trigram_counts:\n for w in self.trigram_counts[u_v]:\n count=self.trigram_counts[u_v][w]\n print \"{2}\\tc({0} {1})\".format(u_v,w,count)","def score(self, sentence):\n # TODO your code here\n\n # initialize count with trained data\n unigram_count = self.count.copy()\n N = self.total\n\n # make a new key for UNK, add-one later\n for token in sentence:\n if token not in unigram_count:\n unigram_count[token] = 0\n\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\n score = 0.0 # P(<s>) = 1\n V = len(unigram_count) # the number of vocab including UNK\n for word in sentence:\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\n score += math.log(prob)\n\n return score","def _getCountForUnigram(self,word1):\n count=self.unigrams[(word1)]\n if count==0:\n count=0.001\n return count","def get_counts(self):\n counts = {}\n for document in self.docs:\n for word in document:\n if word not in counts.keys():\n counts[word] = 1\n else:\n counts[word] += 1\n return counts","def __init__(self, n, sents, gamma=None, addone=True):\n assert n > 0\n self._n = n\n\n if gamma is not None:\n # everything is training data\n train_sents = sents\n else:\n # 90% training, 10% held-out\n m = int(0.45 * len(sents))\n l = int(0.65 * len(sents))\n train_sents = sents[:m] + sents[l:]\n held_out_sents = sents[m:l]\n\n print('Computing counts...')\n count = defaultdict(int)\n while (n >= 0):\n for sent in train_sents:\n s = sent[:] ## En una oracion auxiliar agrego el item de start y end para contarlos\n s.insert(0, \"<s>\")\n s.append(\"</s>\")\n for i in range(len(s) - n + 1):\n count[tuple(s[i:i + n])] += 1\n n -= 1\n count[()] = count[()] - count[('<s>',)] - count[\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\n self._count = count\n # WORKed HERE!!\n # COMPUTE COUNTS FOR ALL K-GRAMS WITH K <= N\n\n # compute vocabulary size for add-one in the last step\n self._addone = addone\n if addone:\n print('Computing vocabulary...')\n self._voc = voc = set()\n for sent in sents:\n voc = voc.union(set(sent))\n voc.add('</s>')\n self._voc = voc\n self._V = len(voc)\n\n # compute gamma if not given\n if gamma is not None:\n self._gamma = gamma\n else:\n print('Computing gamma...')\n self._gamma = gamma = 1\n p = self.log_prob(held_out_sents)\n new_gamma = 2\n streak = 1\n growing = True\n turns = 0\n while (turns < 15):\n self._gamma = new_gamma\n np = self.log_prob(held_out_sents)\n gamma = new_gamma\n if (np > p):\n if growing:\n streak += 1\n else:\n turns += 1\n streak = 0\n growing = True\n new_gamma = new_gamma + 2 ** streak\n else:\n if growing:\n turns += 1\n streak = 0\n growing = False\n else:\n streak += 1\n new_gamma = new_gamma - 2 ** streak\n p = np\n self._gamma = new_gamma\n print(self._gamma)","def word_frequency( tokenized, dic ):\n print( 'computing word frequencies' )\n start = time.time()\n for i, text in enumerate( tokenized ):\n for token in text:\n if token not in dic:\n dic[ token ] = 1\n else:\n dic[ token ] += 1\n if i % 10000 == 0:\n sys.stdout.write( '\\rprocessed : {}/{} reviews in {}s'.format( i, NO_REVIEWS, time.time() - start ) )\n sys.stdout.write( '\\rprocessed : {}/{} reviews in {}s\\n'.format( i, NO_REVIEWS, time.time() - start ) )","def pop_bigrams(self):\n bigram_counts = self.process_file(self.bigram_file)\n N = sum(bigram_counts.values())\n for bigram in bigram_counts:\n self.bigrams[bigram.lower()] = bigram_counts[bigram] / N","def store_counts(storage, counter):\n for ngram, count in counter.items():\n try:\n stored_count = storage[ngram]\n except KeyError:\n stored_count = 0\n storage[ngram] = stored_count + count\n\n storage.sync()\n counter.clear()","def train(self, corpus): \n for sentence in corpus.corpus: # iterate over sentences in the corpus\n for token in sentence: # iterate over datums in the sentence\n self.unigrams[token] += 1\n self.total += 1\n V = len(self.unigrams) # vocabulary size \n for ug,count in self.unigrams.iteritems():\n \tself.f1[ug] = math.log10(count+1) - math.log10(self.total + V)","def initialize_document_frequencies():\n global document_frequency\n for term in dictionary:\n document_frequency[term] = len(postings[term])","def train_ngrams(dataset):\n trigram_counts = dict()\n bigram_counts = dict()\n unigram_counts = dict()\n token_count = 0\n\n ### YOUR CODE HERE\n def enterDic(phrase, dict):\n if phrase in dict:\n dict[phrase] += 1\n else:\n dict[phrase] = 1\n\n unigram_counts[word_to_num['UUUNKKK']] = 0\n\n for sentence in dataset:\n enterDic(sentence[1], unigram_counts) # count number of start of sentences\n enterDic((sentence[0], sentence[1]), bigram_counts) # count number of start of sentences\n token_count += 2\n for i in range(2, len(sentence)):\n token_count += 1\n enterDic(sentence[i], unigram_counts)\n enterDic((sentence[i - 1], sentence[i]), bigram_counts)\n enterDic((sentence[i - 2], sentence[i - 1], sentence[i]), trigram_counts)\n ### END YOUR CODE\n return trigram_counts, bigram_counts, unigram_counts, token_count","def update(self,haiku, typenum):\n self.occurrences += 1\n for i in range(2):\n for x in (haiku.triple[i]).wordarray:\n if (self.wordtype == dictionary.wordtype(x) and \n dictionary.word_filter(x) != self.word):\n self.update_adj_dict(x, i==typenum)","def _update_counts(self, msg, subtype, by):\n\n try:\n counts = self.get_local(msg, \"counts\")\n except KeyError:\n counts = defaultdict(int)\n\n counts['all'] += by\n counts[subtype] += by\n self.set_local(msg, \"counts\", counts)","def __init__(self, corpus):\n self.unigramCounts = collections.defaultdict(lambda: 0)\n self.bigramCounts = collections.defaultdict(lambda: 0)\n self.total = 0\n self.train(corpus)","def on_text(self, event):\n self.get_counts()\n self.save()","def fit(self, text):\n\n if self.lowercase:\n text = text.lower()\n\n print(\"Tokenize sentences...\")\n tokens = word_tokenize(text)\n\n self.words_set_size = len(set(tokens))\n\n print(\"Collecting of ngram counters...\")\n\n self.unigram_counts = Counter(tokens)\n self.bigram_counts = Counter(bigrams(tokens))\n\n return self","def generate_counts():\n\n counts_dict = {}\n folder_path = os.listdir(args.f)\n for subfolder in folder_path:\n subfolder_path = os.path.join(args.f, subfolder)\n for filename in os.listdir(subfolder_path):\n doc_path = os.path.join(subfolder_path, filename)\n with open(doc_path, 'r') as file:\n read_file = file.read()\n normalised_text = re.sub(r\"[^\\s\\w]\", \" \", read_file.lower())\n counts_dict.update({doc_path: collections.Counter(normalised_text.split())})\n #print(counts_dict.get('file/crude/article560.txt'))\n\n vocab = generate_vocab()\n for value in counts_dict.values():\n for k in vocab.keys():\n if k not in value.items():\n value.update({k: 0})\n\n #print(counts_dict.get('file/crude/article560.txt'))\n return counts_dict","def frequency(self):\n # BEGIN\n \n freq = {} \n # for word in my_list:\n # for letter in word:\n # keys=freq.keys()\n # if letter in keys:\n # freq[letter]+=1\n # else:\n # freq[letter]=1\n # return freq\n\n whole = ''.join(WordSet(self.text).words())\n \n for m in whole:\n if m in freq:\n freq[m] += 1\n else:\n freq[m] = 1\n return freq\n # END","def partial_accumulate(self, texts, window_size):\n self._current_doc_num = -1\n self._token_at_edge = None\n self._counter.clear()\n\n super(WordOccurrenceAccumulator, self).accumulate(texts, window_size)\n for combo, count in iteritems(self._counter):\n self._co_occurrences[combo] += count\n\n return self","def train_ngrams(dataset):\n trigram_counts = dict()\n bigram_counts = dict()\n unigram_counts = dict()\n token_count = 0\n ### YOUR CODE HERE\n raise NotImplementedError\n ### END YOUR CODE\n return trigram_counts, bigram_counts, unigram_counts, token_count","def compute_vocab_count(sents):\n counter = collections.Counter()\n for sentence in sents:\n counter.update(untag(sentence))\n return counter","def _count_vocab(self,raw_documents, fixed_vocab=False):\n if fixed_vocab:\n vocabulary = self.vocabulary_\n else:\n # Add a new value when a new vocabulary item is seen\n vocabulary = defaultdict()\n vocabulary.default_factory = vocabulary.__len__\n\n analyze = super().build_analyzer()\n \n j_indices = []\n indptr = []\n\n values = array.array(str('f'))\n indptr.append(0)\n for doc in raw_documents:\n #doc = tupla[0]\n feature_counter = {}\n #texttlist = doc.split(sep=\" \")\n for feature in analyze(doc):#texttlist:\n try:\n \n # Ignore out-of-vocabulary items for fixed_vocab=True\n feature_idx = vocabulary[feature]\n #print(feature_idx)\n #fti_feature = calc_fti(feature,raw_documents)\n \n if feature_idx not in feature_counter:\n feature_counter[feature_idx] = 1\n else:\n feature_counter[feature_idx] += 1\n #print(feature_counter[feature_idx])\n except KeyError:\n # Ignore out-of-vocabulary items for fixed_vocab=True\n continue\n\n\n j_indices.extend(feature_counter.keys())\n values.extend(feature_counter.values())\n indptr.append(len(j_indices))\n\n if not fixed_vocab:\n # disable defaultdict behaviour\n vocabulary = dict(vocabulary)\n if not vocabulary:\n raise ValueError(\"empty vocabulary; perhaps the documents only\"\n \" contain stop words\")\n\n if indptr[-1] > np.iinfo(np.int32).max: # = 2**31 - 1\n if _IS_32BIT:\n raise ValueError(('sparse CSR array has {} non-zero '\n 'elements and requires 64 bit indexing, '\n 'which is unsupported with 32 bit Python.')\n .format(indptr[-1]))\n indices_dtype = np.int64\n\n else:\n indices_dtype = np.int32\n \n j_indices = np.asarray(j_indices, dtype=indices_dtype)\n indptr = np.asarray(indptr, dtype=indices_dtype)\n \n #print (vocabulary)\n X = sp.csr_matrix((values, j_indices, indptr),\n shape=(len(indptr) - 1, len(vocabulary)),\n dtype=np.float32)\n X.sort_indices() \n \n self.vocabulary_calculated = vocabulary\n\n return vocabulary, X","def score(self, sentence):\n # count each incremented word\n for word in sentence:\n if word not in self.unigramCounts:\n self.zeroCount += 1\n\n # apply laplace smoothing to unigram model\n score = 0.0\n for word in sentence:\n count = self.unigramCounts[word]\n score += math.log(count + 1)\n score -= math.log(self.totalCount + self.zeroCount)\n return score","def add_ngrams(mydict,sentence):\n ngrams = get_ngrams(sentence,2,3)\n for ngram in ngrams:\n if ngram in mydict:\n mydict[ngram]+=1\n else:\n mydict[ngram]=1\n return mydict","def _ngram_counter(self, ngram, ngram_length, text_id, doc):\n\n # Only process this ngram is it's punctuation-free (punct --> token.dep == ss.punct) and the 1st / last\n # words are not stopwords (line mechanics: make a set, look for an intersection with another set)\n if ([word for word in ngram if word.dep == ss.punct] or\n {ngram[0].lemma_, ngram[ngram_length - 1].lemma_}.intersection(self.stop_words)):\n return\n\n # Only keep this ngram is it has 1+ nouns in it\n if len([word for word in ngram if word.pos in self.nouns or word.ent_type in self.entities]) == 0:\n return\n\n ngram_lemma = ' '.join([word.text.lower() if word.lemma_ == '-PRON-' else word.lemma_ for word in ngram])\n verbatim = ' '.join([word.text.lower() for word in ngram])\n\n # add the ngram_lemma to each proximal topic\n window_start = 0 if ngram[0].i < 7 else ngram[0].i - 7\n window_end = len(doc) if ngram[0].i + 7 + ngram_length > len(doc) else ngram[0].i + 7 + ngram_length\n for word in doc[window_start:window_end]:\n if word.lemma_ in self.topics: # is this a topic we're tracking?\n # Yes. So let's add it to the subtopic dictionary (with an occurrence count)\n if ngram_lemma in self.topics[word.lemma_]['subtopics']:\n self.topics[word.lemma_]['subtopics'][ngram_lemma].add(text_id)\n else:\n self.topics[word.lemma_]['subtopics'][ngram_lemma] = {text_id}\n\n # TODO: Do I even need self.ngrams anymore? Maybe track everything in the subtopics area?\n # Keep it! And it's not the first time we've found it.\n if ngram_lemma in self.ngrams:\n self.ngrams[ngram_lemma][\"count\"] += 1\n self.ngrams[ngram_lemma][\"textIDs\"] |= {text_id}\n self.ngrams[ngram_lemma][\"verbatims\"] |= {verbatim}\n # Keep it! This is the 1st instance.\n else:\n self.ngrams[ngram_lemma] = {\"name\": ngram_lemma,\n \"count\": 1,\n \"textIDs\": {text_id},\n \"n\": ngram_length,\n \"verbatims\": {verbatim},\n \"topic_lemmas\": []}","def update_words(data, book_num):\n\tglobal word_count\n\t#find count of each word in the book and update the dictionary\n\tfor words in data:\n\t\tword_count[words][book_num] = (word_count.get(words,0)[book_num] + 1)\n\t#print(word_count)","def train(self, corpus):\n\n\n temp = \"\"\n for sentence in corpus.corpus:\n\n i = 0\n for datum in sentence.data:\n # print str(sentence.data)\n self.total=self.total+1\n token = datum.word\n self.unigramCounts[token] = self.unigramCounts[token] + 1\n if (i == 0):\n temp = datum.word\n i = i + 1\n continue\n\n i = i + 1\n\n key = temp + \",\" + token\n self.bigramCounts[key] = self.bigramCounts[key] + 1\n # print token\n temp = token\n\n pass","def __init__(self, corpus):\n self.unigramCounts = collections.defaultdict(lambda: 0)\n self.totalCount = 0\n self.zeroCount = 0\n self.train(corpus)","def trigram_model(list_of_words, bigram_count, trigram_count):\n c_start = list_of_words.count(start_phrase)\n c_end = list_of_words.count(end_phrase)\n if c_start == 0:\n list_of_words.insert(0, start_phrase)\n list_of_words.insert(0, start_phrase)\n if c_start == 1:\n list_of_words.insert(0, start_phrase)\n if c_end == 0:\n list_of_words.append(end_phrase)\n list_of_words.append(end_phrase)\n if c_end == 1:\n list_of_words.append(end_phrase)\n bigram_count = pd.read_csv(bigram_count)\n trigram_count = pd.read_csv(trigram_count)\n proba_dict = {list_of_words[i] + \" \" + list_of_words[i+1] + \" \" + list_of_words[i+2]:\n ((trigram_count[list_of_words[i] + \" \" + list_of_words[i+1] + \" \" + list_of_words[i+2]].values[0]) /\n float(bigram_count[list_of_words[i] + \" \" + list_of_words[i+1]].values[0]))\n if list_of_words[i] + \" \" + list_of_words[i+1] + \" \" + list_of_words[i+2] in trigram_count.columns.values else 0.0 for i in xrange(len(list_of_words) - 2)}\n return proba_dict","def unigram(tokens):\n model = collections.defaultdict(lambda: 0.01)\n for token in tokens:\n try:\n model[token] += 1\n except KeyError:\n model[token] = 1\n continue\n for word in model:\n model[word] = model[word]/float(sum(model.values()))\n return model","def computeTF(self):\n for word in self.dictionary:\n self.dictionary[word].setTF(self.getTotalTerms())","def train(self, corpus):\n for sentence in corpus.corpus:\n cleanSentence = sentence.cleanSentence()\n for datum in cleanSentence.data:\n token = datum.word\n self.unigramCounts[token] = self.unigramCounts[token] + 1\n self.total += 1\n\n i = 0\n while i < len(sentence.data) - 1:\n token = str(cleanSentence.get(i))\n self.followingWords[token].add(str(cleanSentence.get(i+1)))\n i += 1\n\n i = 1\n while i < len(sentence.data):\n bigram = str(cleanSentence.get(i-1)) + \" \" + str(cleanSentence.get(i))\n self.bigramCounts[bigram] = self.bigramCounts[bigram] + 1\n\n self.precedingWords[str(cleanSentence.get(i))].add(str(cleanSentence.get(i-1)))\n i += 1\n self.precedingWordsTotal = sum(map(lambda x: len(x), self.precedingWords.values()))\n\n i = 2\n while i < len(sentence.data):\n trigram = str(cleanSentence.get(i-2)) + \" \" + str(cleanSentence.get(i-1)) + \" \" + str(cleanSentence.get(i))\n self.trigramCounts[trigram] = self.trigramCounts[trigram] + 1\n i += 1\n\n #print('precedingWords')\n #print(self.precedingWords)\n #print('followingWords')\n #print(self.followingWords)\n #print('unigrams')\n #print(self.unigramCounts)\n #print('bigrams')\n #print(self.bigramCounts)\n\n #self.discount(self.trigramCounts)\n #self.discount(self.bigramCounts)\n #self.discount(self.unigramCounts)","def buildDict(self, dict):\n self.all_words = set(dict)\n self.wc_dict = collections.defaultdict(int)\n for w in dict:\n for wc in self.get_wildcards(w):\n self.wc_dict[wc] += 1","def __cross_wiki_counts(self):\n\n print(\"Updating counts by merging with CrossWiki\")\n\n cnt = 0\n crosswiki_path = os.path.join(\n self.base_url, \"generic/p_e_m_data/crosswikis_p_e_m.txt\"\n )\n\n with open(crosswiki_path, \"r\", encoding=\"utf-8\") as f:\n for line in f:\n parts = line.split(\"\\t\")\n mention = unquote(parts[0])\n\n if (\"Wikipedia\" not in mention) and (\"wikipedia\" not in mention):\n if mention not in self.wiki_freq:\n self.wiki_freq[mention] = {}\n\n num_ents = len(parts)\n for i in range(2, num_ents):\n ent_str = parts[i].split(\",\")\n ent_wiki_id = int(ent_str[0])\n freq_ent = int(ent_str[1])\n\n if (\n ent_wiki_id\n not in self.wikipedia.wiki_id_name_map[\"ent_id_to_name\"]\n ):\n ent_name_re = self.wikipedia.wiki_redirect_id(ent_wiki_id)\n if (\n ent_name_re\n in self.wikipedia.wiki_id_name_map[\"ent_name_to_id\"]\n ):\n ent_wiki_id = self.wikipedia.wiki_id_name_map[\n \"ent_name_to_id\"\n ][ent_name_re]\n\n cnt += 1\n if (\n ent_wiki_id\n in self.wikipedia.wiki_id_name_map[\"ent_id_to_name\"]\n ):\n if mention not in self.mention_freq:\n self.mention_freq[mention] = 0\n self.mention_freq[mention] += freq_ent\n\n ent_name = self.wikipedia.wiki_id_name_map[\n \"ent_id_to_name\"\n ][ent_wiki_id].replace(\" \", \"_\")\n if ent_name not in self.wiki_freq[mention]:\n self.wiki_freq[mention][ent_name] = 0\n self.wiki_freq[mention][ent_name] += freq_ent","def __parse_corpus(self, corpus):\n corpus = self.__handle_corpus_unkwon_words(corpus)\n start_token = ' '.join([NGramModel.START_SENTENCE_TOKEN]*(self.__n-1))\n word_list = corpus.replace(NGramModel.START_SENTENCE_TOKEN, start_token).split()\n \n for n in range(1, self.__n+1): \n self.__ngram_counts[n] = {}\n for ngram, count in Counter(self.__generate_n_grams(word_list, n)).items():\n self.__ngram_counts[n][' '.join(ngram)] = count","def term_frequency(ngrams,lang):\n token_dictionary = {}\n for ng in ngrams:\n try:\n token_dictionary[ng] = token_dictionary[ng] + 1\n except KeyError:\n token_dictionary[ng] = 1\n return token_dictionary","def add_to_dict(self, tokens):\n# TODO: ?add normalization of a token?\n for token in tokens:\n if self.embedding_words and (token not in self.embedding_words):\n continue\n self.freq[token] += 1\n if token not in self.tok2ind:\n index = len(self.tok2ind)\n self.tok2ind[token] = index\n self.ind2tok[index] = token","def count_words(self, contents):\n wordCounts = {}\n for i in self.ngramCounts:\n if i == 0: # want the default to be the size of the corpus\n total = 0\n for line in contents:\n words = line.split(\" \")\n words = [ w.strip() for w in words if w] #remove nulls\n for word in words:\n if word:\n total += 1\n wordCounts[i] = defaultdict(lambda: total)\n continue\n else:\n counts = defaultdict(lambda: 0)\n for line in contents:\n words = line.split(\" \")\n words = [ w.strip() for w in words if w] #remove nulls\n for k, word in enumerate(words): \n if k < (i-1) or not word:\n continue\n key = \"\"\n for j in range(k-i+1, k+1):\n key += words[j] + \" \"\n counts[key.strip()] += 1\n wordCounts[i] = counts\n return wordCounts","def convert_word_to_count(counter={}, doc=[]):\n for sentence in doc:\n for word in sentence.split():\n if word not in counter:\n counter[word] = 1\n else:\n counter[word] += 1\n return counter","def count_words_and_dublicates(novel):","def __init__(self, n, sents):\n assert n > 0\n self._n = n\n print(\"Counting...\")\n count = defaultdict(int)\n while n >= 0:\n for sent in sents:\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\n s.insert(0, \"<s>\")\n s.append(\"</s>\")\n for i in range(len(s) - n + 1):\n count[tuple(s[i:i + n])] += 1\n n -= 1\n count[()] = count[()] - count[('<s>',)] - count[\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\n self._count = count\n print(\"Computing vocabulary...\")\n self._voc = voc = set()\n for sent in sents:\n voc = voc.union(set(sent))\n voc.add('</s>')\n self._voc = voc\n self._V = len(voc) # vocabulary size\n print(\"Done\")","def get_counts(data):\n\n word_count = {}\n syll_count = {}\n\n infile = data.corpus\n try:\n\n open_file = codecs.open(infile, 'r', encoding='utf-16')\n for line in open_file:\n line = line.lower()\n # Remove tablet indexing info and line numbers. Grab only text data\n line = line.split(',')\n text = clean_line(line[7])\n\n # Update the occurrences of the words in the line\n for word in text.split():\n count = word_count.setdefault(word, 0)\n word_count[word] = count + 1\n\n # Track occurrences of syllables\n update_syllable_count(word, syll_count)\n\n open_file.close()\n except IOError:\n print(\"Cannot open: \" + infile)\n\n return (word_count, syll_count)","def update_vocab(self, text):\n for char in text:\n if char not in self.vocab:\n self.vocab[char] = len(self.vocab)\n if char not in self.char2count:\n self.char2count[char] = 0\n self.char2count[char] += 1\n return","def phrase_scoring_ranking(phrases,model,dataset,bitext):\n e_phrases = []\n f_phrases = []\n count = 0\n f_phrase_count = {}\n e_phrase_count = {} #not needed\n #e_f_pair_count = {} #e words as rows and f words as columns\n f_e_pair_count = {} #e words as rows and f words as columns\n for phrase_set in phrases:\n for phrase in phrase_set:\n e_phrases.append(phrase[3])\n f_phrases.append(phrase[2])\n if phrase[2] in f_phrase_count:\n f_phrase_count[phrase[2]] += 1\n else:\n f_phrase_count[phrase[2]] = 1\n if phrase[2] in f_e_pair_count:\n if phrase[3] in f_e_pair_count[phrase[2]]:\n f_e_pair_count[phrase[2]][phrase[3]] += 1\n else:\n f_e_pair_count[phrase[2]][phrase[3]] = 1\n else:\n f_e_pair_count[phrase[2]]={}\n f_e_pair_count[phrase[2]][phrase[3]] = 1\n\n e_phrases = list(set(e_phrases))\n f_phrases = list(set(f_phrases))\n ep_count = len(e_phrases)\n fp_count = len(f_phrases)\n #pmatrix = np.empty(ep_count*fp_count) # ######Not needed if dictionary is used\n #pmatrix = pmatrix.reshape(ep_count,fp_count)\n #pmatrix.fill(0)\n ef_prob_dict = {}\n for e in e_phrases:\n for f in f_phrases:\n ef_count =count_fe_pair(e,f,f_e_pair_count)# f_e_pair_count[e][f]\n f_count = f_phrase_count[f]\n e_idx = e_phrases.index(e) ###Check the count logic again\n f_idx = f_phrases.index(f)\n pair_prob = ef_count/f_count\n #pmatrix[e_idx][f_idx] = pair_prob\n if f in f_e_pair_count:\n if e in f_e_pair_count[f]:\n if f in ef_prob_dict:\n ef_prob_dict[f][e]=pair_prob\n else:\n ef_prob_dict[f] = {}\n ef_prob_dict[f][e] = pair_prob\n\n #if pmatrix[e_idx][f_idx] != 0:\n # print(e,f,ef_count,f_count,pair_prob)\n return ef_prob_dict","def score(self, sentence):\n\n score = 0.0\n i = 0\n temp = \"\"\n for token in sentence:\n count = self.unigramCounts[token]\n if (i == 0):\n i = i + 1\n temp = token\n continue\n\n key = temp + \",\" + token\n bicount = self.bigramCounts[key]\n unicount = self.unigramCounts[temp]\n temp = token\n if bicount > 0 :\n\n score += (math.log(bicount) - math.log(unicount))\n else:\n unicount = self.unigramCounts[token]\n score += math.log(unicount + 1) + math.log(0.4)\n score -= math.log(self.total + len(self.unigramCounts))\n\n return score","def construct_ngrams_dict(ngrams_list):\n counts = {}\n\n for t in ngrams_list:\n key = hash_function(t)\n if key in counts:\n counts[key] += 1\n else:\n counts[key] = 1\n return counts","def countize(word, ind, count_words, features):\n word = clean(word)\n word = word.split()\n if len(word)>1:\n for i in range(1,len(word)):\n bigram = (word[i-1],word[i])\n count_words[ind].append(bigram)\n features.append(bigram)\n if len(word)>2:\n for i in range(2,len(word)):\n trigram = (word[i-2],word[i-1], word[i])\n count_words[ind].append(trigram)\n features.append(trigram)\n for i in range(len(word)):\n unigram = word[i]\n count_words[ind].append((unigram))\n features.append((unigram))\n return count_words, features","def calc_tf(doc):\r\n tf = {}\r\n for term in doc:\r\n if term not in tf:\r\n tf[term] = doc.count(term)\r\n return tf","def get_frequencies(tokens):\n cnt = {}\n\n for word in tokens:\n if word not in cnt:\n cnt[word] = 0\n\n cnt[word] += 1\n\n return cnt","def set_grams(data_path,top=100):\n files = glob.glob(data_path + \"/*/*word*.txt\") # txt files in subfolders\n ngram = []\n table = str.maketrans(\"\",\"\",string.punctuation)\n for f_in in files:\n with open(f_in, 'r') as fi:\n for lines in fi:\n item = lines.replace(\"\\n\",\"\").split()\n term = \"\"\n count = 0\n if len(item)==3: # bigrams\n term0 = str(item[0]).translate(table).strip()\n term1 = str(item[1]).translate(table).strip()\n term = \"{},{}\".format(term0,term1) if (len(term0)>2 and len(term1)>2 and not term0.isnumeric() and not term1.isnumeric()) else (term0 if (len(term0)>2 and not term0.isnumeric()) else (term1 if (len(term1)>2 and not term1.isnumeric()) else \"\")) # comma(,) for OR in Twitter \n count = int(item[2])\n elif len(item)==2: # unigrams\n term = str(item[0]).translate(table).strip()\n count = int(item[1])\n if count>=top and str(term) != 'nan' and len(term)>=3: # ignore term freq minor than top and term length than 3\n ngram.append(term)\n fi.close()\n gn_set = set(ngram)\n \n print(len(gn_set))\n \n f = open(data_path+\".txt\", 'w')\n for w in gn_set:\n f.write('{}\\n'.format(w))\n f.close()\n \n return list(gn_set)","def computeWordFrequencies(self, tokens: ['token'], frequencies: {'token': int}):\n # project2: update this method to take existing dict as parameter and modify it\n # additionally, stopwords are not inserted in the dict;\n # words shorter than 3 character or contains all digits are ignored\n for token in tokens:\n # if the key is not in dict, dict.setdefault method initiates the value at 0\n # if token not in stopwords and len(token) >= 3 and not token.isdigit():\n frequencies[token] = frequencies.setdefault(token, 0) + 1","def _collect_counts(self):\n for t in self.system.keys():\n if t in self.gold:\n self.tp += 1\n else:\n self.fp += 1\n for t in self.gold.keys():\n if t not in self.system:\n self.fn += 1","def frequencies(corpus, index, to_lower=False):\n freq = {}\n for sentence in corpus.get_sentences():\n for word in sentence:\n key = word[index]\n if to_lower:\n key = key.lower()\n if key in freq:\n freq[key] += 1\n else:\n freq[key] = 1\n\n return freq","def build_ngram_index(tokenized_documents, ngrams):\n dictionary = {}\n\n doc_ngrams = {}\n for doc in tokenized_documents:\n ngrams_freq = {}\n\n measures = nltk.collocations.BigramAssocMeasures()\n finder = BigramCollocationFinder.from_words(tokenized_documents[doc])\n freqs = finder.ngram_fd\n for ngram in freqs:\n ngrams_freq[ngram] = freqs[ngram]\n \n measures = nltk.collocations.TrigramAssocMeasures()\n finder = TrigramCollocationFinder.from_words(tokenized_documents[doc])\n freqs = finder.ngram_fd\n for ngram in freqs:\n ngrams_freq[ngram] = freqs[ngram]\n\n doc_ngrams[doc] = ngrams_freq\n\n for ngram in ngrams:\n dictionary[ngram] = [0]\n for doc in doc_ngrams:\n if ngram in doc_ngrams[doc]:\n dictionary[ngram][0] += doc_ngrams[doc][ngram]\n dictionary[ngram].append((doc, doc_ngrams[doc][ngram]))\n \n return dictionary","def train(self, iterable):\n for ngram in generate_ngrams(iterable, self.n + 1):\n self.markov_dict.setdefault(ngram[: self.n], Counter()).update([ngram[self.n]])\n self.prob_dict.update([ngram[: self.n]])","def count_terms(self, tokens):\n\n terms = [self.term_match(t) for t in tokens ]\n \n terms = [t for t in terms if t != None]\n\n #print terms\n lf = dict(Counter(terms))\n for k in lf:\n lf[k] /= float(len(tokens))\n #lf[k] = 1 # binarize?\n pass\n return lf","def compute_frequencies(num_words, documents):\n res = [0 for i in range(num_words)]\n sum = 0\n for word in documents:\n sum += 1\n tmp = set(word)\n for number in tmp:\n res[number] += 1\n \n res = [i / sum for i in res]\n return res","def count_doc_frequencies(self, docs):\n frequencyIndex = {}\n doc_id = 0\n for doc in docs:\n for term in doc:\n if term not in frequencyIndex:\n frequencyIndex[term] = [doc_id]\n else:\n for id in frequencyIndex[term]:\n if doc_id == id:\n break\n else:\n frequencyIndex[term].append(doc_id)\n doc_id+=1\n\n for term in frequencyIndex:\n occurences = len(frequencyIndex[term])\n frequencyIndex[term] = occurences\n\n return frequencyIndex","def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) -> Counter:\n ngram_counter: Counter = Counter()\n\n for i in range(1, n_gram + 1):\n for j in range(len(ngram_input_list) - i + 1):\n ngram_key = tuple(ngram_input_list[j : (i + j)])\n ngram_counter[ngram_key] += 1\n\n return ngram_counter","def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) ->Counter:\n ngram_counter: Counter = Counter()\n for i in range(1, n_gram + 1):\n for j in range(len(ngram_input_list) - i + 1):\n ngram_key = tuple(ngram_input_list[j:i + j])\n ngram_counter[ngram_key] += 1\n return ngram_counter","def _update_triad_counts(self):\n for i in range(len(self.learning_string) - 3):\n triad = self.learning_string[i] + self.learning_string[i + 1] + self.learning_string[i + 2]\n\n if self.learning_string[i + 3] == '0':\n self.triad_counts[triad][0] += 1\n elif self.learning_string[i + 3] == '1':\n self.triad_counts[triad][1] += 1\n\n return","def add_unique_word_count(self):\n call_count = lambda letter_: self._count_unique_words(letter_)\n self.dataframe['unique_words'] = self.dataframe['letter'].map(call_count)","def update_word_stats(self, tweet):\n\n if not self.text:\n return\n\n words = self.text.split()\n\n # process single words\n for word in words:\n self.update_stats('words', word)\n\n # process 2 word lists\n pairs = self.get_phrase_list(words, 2)\n if pairs is not None:\n for word_pair in pairs:\n self.update_stats('word_pairs', self.get_index_from_list(word_pair))\n\n # process 3 word lists\n triples = self.get_phrase_list(words, 3)\n if triples is not None:\n for word_triple in triples:\n self.update_stats('word_triples', self.get_index_from_list(word_triple))","def add(counts):\n if counts:\n for k in grammar.keys():\n grammar[k] = grammar[k] + counts[k]","def num_bigram(doc):\n matched_spans = []\n matches = matcher(doc)\n for match_id, start, end in matches:\n span = doc[start:end]\n matched_spans.append(span)\n for span in matched_spans: # merge into one token after collecting all matches\n span.merge()\n return doc","def preprocess(self, documents):\n\n # A dict storing the frequency of each word\n word_freq = {}\n\n # Iterate for each document\n for doc in documents:\n # Split the document into a list of words and iterate on it\n for w in extract_words(doc):\n # Update word frequencies\n '''YOUR CODE HERE'''\n if w not in word_freq.keys():\n word_freq[w] = 1\n else:\n word_freq[w] += 1\n\n ''' END CODE FOR THIS LOOP '''\n\n\n # A set of words with frequency less than 'self.min_freq'\n remove_words = set()\n\n # Check frequency of each word and add to 'remove_words'\n # if it's frequency is below self.min_freq\n\n ''' YOUR CODE HERE '''\n for w in word_freq.keys():\n if word_freq[w] < self.min_freq:\n remove_words.add(w)\n\n # Delete the words in 'remove_words' from 'word_freq'\n for w in remove_words:\n del word_freq[w]\n\n # Fill 'self.word_to_idx' and 'self.idx_to_word' for\n # each word in 'word_freq' (dicts are explained above)\n\n i = 0\n for w in word_freq.keys():\n self.word_to_idx[w] = i\n self.idx_to_word[i] = w \n i += 1\n\n ''' END YOUR CODE HERE '''","def test_fill_in_dic():\n ngrams = NgramFrequencies()\n word_per_list = [\"time\", \"burton's\", \"corpse\", \"bride\"]\n ngrams.fill_in_dic(word_per_list)\n assert ngrams.unigrams_dic == {\n \"COUNT\": 4,\n \"time\": 1,\n \"burton's\": 1,\n \"corpse\": 1,\n \"bride\": 1\n }\n assert ngrams.bigrams_dic == {\n \"COUNT\": 3,\n \"time_burton's\": 1,\n \"burton's_corpse\": 1,\n \"corpse_bride\": 1\n }\n assert ngrams.trigrams_dic == {\n \"COUNT\": 2,\n \"time_burton's_corpse\": 1,\n \"burton's_corpse_bride\": 1\n }","def unigram_model(list_of_words, unigram_count, N=count_token()):\n d = pd.read_csv(unigram_count)\n proba_dict = {list_of_words[i]: (d[el].values[0] / float(N)) if el in d.columns.values else 0.0 for i, el in enumerate(list_of_words) }\n return proba_dict","def __init__(self, corpus):\n self.total = 0\n self.reverseBigramCount = defaultdict(lambda : defaultdict(lambda : 0))\n self.bigramCount = defaultdict(lambda : defaultdict(lambda : 0))\n self.unigramCount = defaultdict(lambda: 0)\n self.train(corpus)","def process_family_frequencies(self, parent, family):\n if not family:\n return None\n counts = {}\n n_tokens = 0\n for description_array in family:\n seen = set([])\n for token in description_array:\n counts[token] = counts.get(token, 0) + 1\n n_tokens += 1\n\n self.word2tf[token] = self.word2tf.get(token, 0) + 1\n self.n_words += 1\n if token not in seen:\n self.word2df[token] = self.word2df.get(token, 0) + 1\n seen.add(token)\n\n self.family2tf[parent] = {tok: count/n_tokens for tok, count in counts.items()}\n self.data.extend(family)\n return True","def frequencies(self):\n dic = {}\n for word in self.words():\n dic[word] = dic.get(word, 0) + 1\n return dic","def countFreq(self,document):\n self.document = document\n vocab=['python','js','android','php','django','javascript','oracle','ruby','rails','java']\n cnt_vector = CountVectorizer(vocabulary=vocab)\n self.freq_term_matrix = cnt_vector.fit_transform(self.document)\n return self.freq_term_matrix.toarray()","def _count_occurrences(self, corpus_tokens: list, window_size: int):\n ngram_occurrences = {}\n for i, corpus_token in enumerate(corpus_tokens):\n ngram = []\n if i + window_size > len(corpus_tokens) - 1:\n break\n else:\n for j in range(window_size):\n ngram.append(corpus_tokens[i + j])\n if self.TOKENS.END.value in ngram:\n continue\n else:\n ngram_key = tuple(ngram)\n if ngram_key in ngram_occurrences:\n ngram_occurrences[ngram_key] += 1\n else:\n ngram_occurrences[ngram_key] = 1\n return ngram_occurrences","def make_word_to_freq(self):\n\t\tword_to_freq = {}\n\t\tdocuments = self.tokenized_documents[\"train\"]\n\t\tfor document in documents:\n\t\t\tfor word in document:\n\t\t\t\tif not word in self.worddict: # make sure we have not found one of the pre-defined words\n\t\t\t\t\tword_to_freq[word] = word_to_freq.get(word, 0) + 1\n\t\t\n\t\treturn word_to_freq","def train(self, corpus): \n # TODO your code here\n # Tip: To get words from the corpus, try\n # for sentence in corpus.corpus:\n # for datum in sentence.data: \n # word = datum.word\n for sentence in corpus:\n prevWord = \"\"\n prevPrevWord = \"\"\n for word in sentence:\n word = word.strip(STRIP_CHARS)\n word = word.lower()\n currentWord = word\n self.unigramCounts[currentWord] += 1\n self.total += 1\n if prevWord != \"\":\n if prevPrevWord != \"\":\n trigram = (prevPrevWord, prevWord, currentWord)\n if trigram not in self.trigramCounts:\n self.continuationCounts[currentWord] += 1\n self.followingCounts[(prevPrevWord, prevWord)] += 1\n self.trigramCounts[trigram] += 1\n self.bigramCounts[(prevWord, currentWord)] += 1\n self.totalBigramCounts += 1\n else:\n self.bigramCounts[(prevWord, currentWord)] += 1\n self.totalBigramCounts += 1\n prevPrevWord = prevWord\n prevWord = currentWord\n else:\n prevWord = currentWord\n self.total += len(self.unigramCounts)","def create_freq_dict(corpus, doc_info):\n for idx, content in enumerate(corpus):\n word_freq_table = {}\n splitted_sentence = content.split()\n for word in splitted_sentence:\n word = word.lower()\n if word not in word_freq_table:\n word_freq_table[word] = 1\n else:\n word_freq_table[word] += 1\n doc_info[idx]['freq_dict'] = word_freq_table","def count_n_grams(data, n, start_token='<s>', end_token = '<e>'):\r\n \r\n # Initialize dictionary of n-grams and their counts\r\n n_grams = {}\r\n\r\n \r\n for sentence in data: # complete this line\r\n \r\n # prepend start token n times, and append <e> one time\r\n sentence = [start_token]*n + sentence + [end_token]\r\n \r\n # convert list to tuple\r\n # So that the sequence of words can be used as\r\n # a key in the dictionary\r\n sentence = tuple(sentence)\r\n\r\n \r\n for i in range(len(sentence)+1-n): # complete this line\r\n\r\n # Get the n-gram from i to i+n\r\n n_gram = sentence[i:i+n]\r\n\r\n # check if the n-gram is in the dictionary\r\n if n_gram in n_grams: \r\n \r\n # Increment the count for this n-gram\r\n n_grams[n_gram] += 1\r\n else:\r\n # Initialize this n-gram count to 1\r\n n_grams[n_gram] = 1\r\n \r\n return n_grams","def addUnigrams(self, rating, writtenReview):\n sentence = writtenReview.split()\n for word in sentence:\n if word not in self.dictionary:\n self.addItem(word)\n self.totalTerms[rating] += 1\n self.dictionary[word].incrementFrequency(rating)","def count(self):\n freq = {}\n\n for desc in self.words:\n if desc in freq:\n freq[desc] += 1\n else:\n freq[desc] = 1\n\n return freq","def normalize(self):\n for key in self.corpus.keys():\n sum_count = 0\n words = []\n counts = []\n for k, v in self.corpus[key].items():\n sum_count += v\n words.append(k)\n counts.append(v)\n prob = [float(count)/sum_count for count in counts]\n\n self.corpus[key] = [words, prob]","def increment_count(self, word):\n pass","def train(self, documents):\n ###DONE\n\n #entire vocab in document set D\n vocab_sod = set()\n vocab_pop = set()\n \n #Calcuates prior probabilities\n priorSOD = 0 #how many docs are spam\n priorPOP = 0 #how many docs are ham\n \n #Cacluates Tct\n term_freq_sod = {} #{term:occur, term:occur}\n term_freq_pop = {}\n \n #Tct'\n Tct_sod = 0 #Tct' = sum of (every term occurence in class c + 1)\n Tct_pop = 0\n \n for doc in documents: \n if 'sod' in doc.label:\n priorSOD += 1\n for token in doc.tokens:\n Tct_sod += 1\n if token in term_freq_sod.keys():\n term_freq_sod[token] = term_freq_sod[token] + 1\n else:\n term_freq_sod[token] = 1\n vocab_sod.add(token) \n else:\n priorPOP += 1\n for token in doc.tokens:\n Tct_pop += 1\n if token in term_freq_pop.keys():\n term_freq_pop[token] = term_freq_pop[token] + 1\n else:\n term_freq_pop[token] = 1\n vocab_pop.add(token)\n \n \n #endfor\n # | is for set join\n self.vocab = vocab_sod | vocab_pop #gets rid of duplicate words (those in both 'ham' and 'spam') \n \n #Tct Primes\n #tct' = term freq of all terms in class c + 1*(total terms)\n Tct_sod = Tct_sod + len(self.vocab) \n Tct_pop = Tct_pop + len(self.vocab) \n \n \n print(\"PriorSod: \" + str(priorSOD))\n print(\"PriorPop: \" + str(priorPOP))\n print(\"LEN Docum: \" + str(len(documents)))\n \n self.priorSOD = priorSOD / len(documents)\n self.priorPOP = priorPOP / len(documents)\n \n for term in self.vocab:\n if term in term_freq_pop.keys():\n self.cond_prob_pop[term] = (term_freq_pop[term] + 1) / Tct_pop\n else:\n self.cond_prob_pop[term] = 1 / Tct_pop\n \n if term in term_freq_sod.keys():\n self.cond_prob_sod[term] = (term_freq_sod[term] + 1) / Tct_sod\n else:\n self.cond_prob_sod[term] = 1 / Tct_sod\n \n \n pass","def _profile(self, text):\n prof = zeros(len(self.alph)**self.N)\n ngs = ngrams(text, self.N)\n for tup in ngs:\n loc = 0\n for i in range(len(tup)):\n loc += (len(self.alph)**i) * self.alph.index(tup[i])\n prof[loc] += 1\n return prof"],"string":"[\n \"def _count(self):\\n words = [word.lower() for word in self.corpus.words()]\\n bigrams_words = bigrams(words)\\n for bigram in bigrams_words:\\n self._bigrams[bigram] += 1\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = {} # might want to use defaultdict or Counter instead\\n self.bigramcounts = {} \\n self.trigramcounts = {} \\n\\n self.total = 2\\n ##Your code here\\n\\n for sentence in corpus:\\n temp_1 = get_ngrams(sentence,1)\\n temp_2 = get_ngrams(sentence,2)\\n temp_3 = get_ngrams(sentence,3)\\n for i in range(len(temp_1)):\\n if temp_1[i] in self.unigramcounts:\\n self.unigramcounts[temp_1[i]] += 1\\n else:\\n self.unigramcounts[temp_1[i]] = 1\\n self.total += 1\\n\\n for i in range(len(temp_2)):\\n if temp_2[i] in self.bigramcounts:\\n self.bigramcounts[temp_2[i]] += 1\\n else:\\n self.bigramcounts[temp_2[i]] = 1\\n\\n for i in range(len(temp_3)):\\n if temp_3[i] in self.trigramcounts:\\n self.trigramcounts[temp_3[i]] += 1\\n else:\\n self.trigramcounts[temp_3[i]] = 1\\n return\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = defaultdict(int)\\n self.bigramcounts = defaultdict(int)\\n self.trigramcounts = defaultdict(int)\\n\\n self.sentence_counts = 0\\n self.word_count = 0\\n\\n for line in corpus:\\n sequence = line\\n self.sentence_counts +=1\\n\\n unigrams = get_ngrams(sequence, n=1)\\n for gram in unigrams:\\n self.word_count += 1\\n self.unigramcounts[gram] +=1\\n\\n bigrams = get_ngrams(sequence, n=2)\\n for gram in bigrams:\\n self.bigramcounts[gram] +=1\\n\\n trigrams = get_ngrams(sequence, n=3)\\n for gram in trigrams:\\n self.trigramcounts[gram] +=1\\n\\n #self.unigramcounts[('START')] = self.sentence_counts *2\\n self.bigramcounts[('START', 'START')] = self.sentence_counts\\n\\n #return self\",\n \"def count_ngrams(self):\\n self.unigram = self.count_unigram(self.word_list)\\n self.bigram = self.count_bigram(self.word_list)\\n # self.trigram = self.count_trigram(self.word_list)\\n # self.four_gram = self.count_four_gram(self.word_list)\\n # self.five_gram = self.count_five_gram(self.word_list)\",\n \"def updateWordCounts():\\n emaildata = loadEmailData()\\n englishwords = importDictionary()\\n countAllWords(emaildata, englishwords)\",\n \"def train(self, corpus):\\n for sentence in corpus.corpus:\\n for datum in sentence.data: \\n self.unigramCounts[datum.word] += 1\\n self.totalCount += 1\",\n \"def train(self, corpus): \\n for sentence in corpus.corpus:\\n prev_word = None\\n for datum in sentence.data:\\n word = datum.word\\n self.unigram_count[word] += 1\\n if prev_word != None:\\n self.bigram_count[prev_word][word] += 1\\n prev_word = word\\n \\n self.vocabulary_size = len(self.unigram_count)\\n self.num_words = sum(self.unigram_count.values())\",\n \"def setCounts(self):\\n N=len(self.y)\\n self.counts=np.zeros(len(self.y))\\n self.idf=np.zeros(len(self.y))\\n for i in range(0,len(self.counts)):\\n for word in self.qtext:\\n wc=self.atext[i].count(word)\\n self.counts[i]+=wc\\n if wc>0:\\n d=0\\n for sentence in self.atext:\\n if word in sentence:\\n d+=1\\n self.idf[i]+=wc*np.log(N/d)\",\n \"def train(self, corpus):\\n lastToken = \\\"#\\\"\\n for sentence in corpus.corpus:\\n for datum in sentence.data:\\n token = datum.word\\n self.reverseBigramCount[token][lastToken] += 1\\n self.bigramCount[lastToken][token] += 1\\n self.unigramCount[token] += 1\\n self.total += 1\\n lastToken = token\",\n \"def get_counts(data):\\n\\n bigrams = {}\\n unigrams = {}\\n #range is len-1 because the bigram uses ith+1 element\\n data=list(data)\\n for i in range(0, len(data)-1):\\n #ith element and ith+1 element\\n bigram=(data[i],data[i+1])\\n if(bigram in bigrams):\\n count=bigrams[bigram]\\n bigrams[bigram]= count+1\\n else:\\n #if bigram not in dict of bigrams, add with count 1\\n bigrams[bigram]=1\\n\\n for unigram in data:\\n if(unigram in unigrams):\\n count=unigrams[unigram]\\n unigrams[unigram]= count+1\\n else:\\n #if unigram not present, add with count 1\\n unigrams[unigram]=1\\n\\n return bigrams,unigrams\",\n \"def pop_bigrams_old(self, corpus):\\n for sentence in corpus.sents():\\n for w1, w2 in bigrams(word_tokenize(sentence), pad_right=True, pad_left=True):\\n self.bigrams[w1][w2] += 1\\n\\n # Convert trigrams to probabilities\\n for wp in self.bigrams:\\n total_count = float(sum(self.bigrams[wp].values()))\\n for w2 in self.bigrams[wp]:\\n self.bigrams[wp][w2] /= total_count\",\n \"def count_ngrams(self, corpus):\\n self.unigramcounts = defaultdict(int) # might want to use defaultdict or Counter instead\\n self.bigramcounts = defaultdict(int)\\n self.trigramcounts = defaultdict(int)\\n\\n self.total_word_count = 0\\n self.total_sentence_count = 0\\n\\n # For each sentence, generate ngram_counts\\n for sentence in corpus :\\n # 2 extra START tokens and 1 extra STOP token\\n self.total_word_count += len(sentence) + 3\\n self.total_sentence_count += 1\\n for unigram in get_ngrams(sentence, 1) :\\n self.unigramcounts[unigram] += 1\\n for bigram in get_ngrams(sentence, 2) :\\n self.bigramcounts[bigram] += 1\\n for trigram in get_ngrams(sentence, 3) :\\n self.trigramcounts[trigram] += 1\\n\\n return\",\n \"def calcCountDict(TFdict):\\n\\n countDict = {}\\n\\n for doc in TFdict:\\n for term in doc:\\n if term in countDict:\\n countDict[term] +=1\\n else:\\n countDict[term] = 1\\n\\n return countDict\",\n \"def update_frequencies():\\n pass\",\n \"def update(self, iterable):\\n for word in iterable:\\n if word in self:\\n self[word] = self[word] + 1\\n self.tokens += 1\\n else:\\n self[word] = 1\\n self.types += 1\\n self.tokens += 1\",\n \"def _count_word_frequency(self, data):\\n _dict = {}\\n for _docs in data:\\n for _word in _docs:\\n if _word in _dict:\\n _dict[_word] += 1\\n else:\\n _dict[_word] = 1\\n return _dict\",\n \"def _collect_counts(self, instance_list):\\n \\\"\\\"\\\" Based on each instance, I augment empirical counts for every word and its BIO label in feature_count_table and for every transition from previous label to current label in transition_count_table.\\n All \\\"rare words\\\" (those words that appear less than 3 times) are replaced by <UNK>.\\n I also add label|START counts.\\n \\\"\\\"\\\"\\n # Build feature_count_table of V x labels and transition_count_table of labels x labels\\n for instance in instance_list: # Set of <(w, pos), l>\\n index = 0\\n for t in instance.data: # Tuple of (w, pos)\\n index = instance.data.index(t)\\n # print t[0] # word\\n # print instance.label[index] # label\\n if t in self.V:\\n self.feature_count_table[self.V.index(t)][self.labels.index(instance.label[index])] +=1\\n else:\\n self.feature_count_table[self.V.index('<UNK>')][self.labels.index(instance.label[index])] +=1\\n if index > 0:\\n self.transition_count_table[self.labels.index(instance.label[index-1])][self.labels.index(instance.label[index])] += 1\\n else:\\n self.transition_count_table[len(self.labels)][self.labels.index(instance.label[index])] += 1\",\n \"def calculate(self, tokens: list):\\n vektor_tf_unigram = {}\\n\\n for token in tokens:\\n if token in vektor_tf_unigram:\\n vektor_tf_unigram[token] = vektor_tf_unigram[token] + 1\\n else:\\n vektor_tf_unigram[token] = 1\\n\\n return vektor_tf_unigram\",\n \"def print_trigrams_count(self):\\n for u_v in self.trigram_counts:\\n for w in self.trigram_counts[u_v]:\\n count=self.trigram_counts[u_v][w]\\n print \\\"{2}\\\\tc({0} {1})\\\".format(u_v,w,count)\",\n \"def score(self, sentence):\\n # TODO your code here\\n\\n # initialize count with trained data\\n unigram_count = self.count.copy()\\n N = self.total\\n\\n # make a new key for UNK, add-one later\\n for token in sentence:\\n if token not in unigram_count:\\n unigram_count[token] = 0\\n\\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\\n score = 0.0 # P(<s>) = 1\\n V = len(unigram_count) # the number of vocab including UNK\\n for word in sentence:\\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\\n score += math.log(prob)\\n\\n return score\",\n \"def _getCountForUnigram(self,word1):\\n count=self.unigrams[(word1)]\\n if count==0:\\n count=0.001\\n return count\",\n \"def get_counts(self):\\n counts = {}\\n for document in self.docs:\\n for word in document:\\n if word not in counts.keys():\\n counts[word] = 1\\n else:\\n counts[word] += 1\\n return counts\",\n \"def __init__(self, n, sents, gamma=None, addone=True):\\n assert n > 0\\n self._n = n\\n\\n if gamma is not None:\\n # everything is training data\\n train_sents = sents\\n else:\\n # 90% training, 10% held-out\\n m = int(0.45 * len(sents))\\n l = int(0.65 * len(sents))\\n train_sents = sents[:m] + sents[l:]\\n held_out_sents = sents[m:l]\\n\\n print('Computing counts...')\\n count = defaultdict(int)\\n while (n >= 0):\\n for sent in train_sents:\\n s = sent[:] ## En una oracion auxiliar agrego el item de start y end para contarlos\\n s.insert(0, \\\"<s>\\\")\\n s.append(\\\"</s>\\\")\\n for i in range(len(s) - n + 1):\\n count[tuple(s[i:i + n])] += 1\\n n -= 1\\n count[()] = count[()] - count[('<s>',)] - count[\\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\\n self._count = count\\n # WORKed HERE!!\\n # COMPUTE COUNTS FOR ALL K-GRAMS WITH K <= N\\n\\n # compute vocabulary size for add-one in the last step\\n self._addone = addone\\n if addone:\\n print('Computing vocabulary...')\\n self._voc = voc = set()\\n for sent in sents:\\n voc = voc.union(set(sent))\\n voc.add('</s>')\\n self._voc = voc\\n self._V = len(voc)\\n\\n # compute gamma if not given\\n if gamma is not None:\\n self._gamma = gamma\\n else:\\n print('Computing gamma...')\\n self._gamma = gamma = 1\\n p = self.log_prob(held_out_sents)\\n new_gamma = 2\\n streak = 1\\n growing = True\\n turns = 0\\n while (turns < 15):\\n self._gamma = new_gamma\\n np = self.log_prob(held_out_sents)\\n gamma = new_gamma\\n if (np > p):\\n if growing:\\n streak += 1\\n else:\\n turns += 1\\n streak = 0\\n growing = True\\n new_gamma = new_gamma + 2 ** streak\\n else:\\n if growing:\\n turns += 1\\n streak = 0\\n growing = False\\n else:\\n streak += 1\\n new_gamma = new_gamma - 2 ** streak\\n p = np\\n self._gamma = new_gamma\\n print(self._gamma)\",\n \"def word_frequency( tokenized, dic ):\\n print( 'computing word frequencies' )\\n start = time.time()\\n for i, text in enumerate( tokenized ):\\n for token in text:\\n if token not in dic:\\n dic[ token ] = 1\\n else:\\n dic[ token ] += 1\\n if i % 10000 == 0:\\n sys.stdout.write( '\\\\rprocessed : {}/{} reviews in {}s'.format( i, NO_REVIEWS, time.time() - start ) )\\n sys.stdout.write( '\\\\rprocessed : {}/{} reviews in {}s\\\\n'.format( i, NO_REVIEWS, time.time() - start ) )\",\n \"def pop_bigrams(self):\\n bigram_counts = self.process_file(self.bigram_file)\\n N = sum(bigram_counts.values())\\n for bigram in bigram_counts:\\n self.bigrams[bigram.lower()] = bigram_counts[bigram] / N\",\n \"def store_counts(storage, counter):\\n for ngram, count in counter.items():\\n try:\\n stored_count = storage[ngram]\\n except KeyError:\\n stored_count = 0\\n storage[ngram] = stored_count + count\\n\\n storage.sync()\\n counter.clear()\",\n \"def train(self, corpus): \\n for sentence in corpus.corpus: # iterate over sentences in the corpus\\n for token in sentence: # iterate over datums in the sentence\\n self.unigrams[token] += 1\\n self.total += 1\\n V = len(self.unigrams) # vocabulary size \\n for ug,count in self.unigrams.iteritems():\\n \\tself.f1[ug] = math.log10(count+1) - math.log10(self.total + V)\",\n \"def initialize_document_frequencies():\\n global document_frequency\\n for term in dictionary:\\n document_frequency[term] = len(postings[term])\",\n \"def train_ngrams(dataset):\\n trigram_counts = dict()\\n bigram_counts = dict()\\n unigram_counts = dict()\\n token_count = 0\\n\\n ### YOUR CODE HERE\\n def enterDic(phrase, dict):\\n if phrase in dict:\\n dict[phrase] += 1\\n else:\\n dict[phrase] = 1\\n\\n unigram_counts[word_to_num['UUUNKKK']] = 0\\n\\n for sentence in dataset:\\n enterDic(sentence[1], unigram_counts) # count number of start of sentences\\n enterDic((sentence[0], sentence[1]), bigram_counts) # count number of start of sentences\\n token_count += 2\\n for i in range(2, len(sentence)):\\n token_count += 1\\n enterDic(sentence[i], unigram_counts)\\n enterDic((sentence[i - 1], sentence[i]), bigram_counts)\\n enterDic((sentence[i - 2], sentence[i - 1], sentence[i]), trigram_counts)\\n ### END YOUR CODE\\n return trigram_counts, bigram_counts, unigram_counts, token_count\",\n \"def update(self,haiku, typenum):\\n self.occurrences += 1\\n for i in range(2):\\n for x in (haiku.triple[i]).wordarray:\\n if (self.wordtype == dictionary.wordtype(x) and \\n dictionary.word_filter(x) != self.word):\\n self.update_adj_dict(x, i==typenum)\",\n \"def _update_counts(self, msg, subtype, by):\\n\\n try:\\n counts = self.get_local(msg, \\\"counts\\\")\\n except KeyError:\\n counts = defaultdict(int)\\n\\n counts['all'] += by\\n counts[subtype] += by\\n self.set_local(msg, \\\"counts\\\", counts)\",\n \"def __init__(self, corpus):\\n self.unigramCounts = collections.defaultdict(lambda: 0)\\n self.bigramCounts = collections.defaultdict(lambda: 0)\\n self.total = 0\\n self.train(corpus)\",\n \"def on_text(self, event):\\n self.get_counts()\\n self.save()\",\n \"def fit(self, text):\\n\\n if self.lowercase:\\n text = text.lower()\\n\\n print(\\\"Tokenize sentences...\\\")\\n tokens = word_tokenize(text)\\n\\n self.words_set_size = len(set(tokens))\\n\\n print(\\\"Collecting of ngram counters...\\\")\\n\\n self.unigram_counts = Counter(tokens)\\n self.bigram_counts = Counter(bigrams(tokens))\\n\\n return self\",\n \"def generate_counts():\\n\\n counts_dict = {}\\n folder_path = os.listdir(args.f)\\n for subfolder in folder_path:\\n subfolder_path = os.path.join(args.f, subfolder)\\n for filename in os.listdir(subfolder_path):\\n doc_path = os.path.join(subfolder_path, filename)\\n with open(doc_path, 'r') as file:\\n read_file = file.read()\\n normalised_text = re.sub(r\\\"[^\\\\s\\\\w]\\\", \\\" \\\", read_file.lower())\\n counts_dict.update({doc_path: collections.Counter(normalised_text.split())})\\n #print(counts_dict.get('file/crude/article560.txt'))\\n\\n vocab = generate_vocab()\\n for value in counts_dict.values():\\n for k in vocab.keys():\\n if k not in value.items():\\n value.update({k: 0})\\n\\n #print(counts_dict.get('file/crude/article560.txt'))\\n return counts_dict\",\n \"def frequency(self):\\n # BEGIN\\n \\n freq = {} \\n # for word in my_list:\\n # for letter in word:\\n # keys=freq.keys()\\n # if letter in keys:\\n # freq[letter]+=1\\n # else:\\n # freq[letter]=1\\n # return freq\\n\\n whole = ''.join(WordSet(self.text).words())\\n \\n for m in whole:\\n if m in freq:\\n freq[m] += 1\\n else:\\n freq[m] = 1\\n return freq\\n # END\",\n \"def partial_accumulate(self, texts, window_size):\\n self._current_doc_num = -1\\n self._token_at_edge = None\\n self._counter.clear()\\n\\n super(WordOccurrenceAccumulator, self).accumulate(texts, window_size)\\n for combo, count in iteritems(self._counter):\\n self._co_occurrences[combo] += count\\n\\n return self\",\n \"def train_ngrams(dataset):\\n trigram_counts = dict()\\n bigram_counts = dict()\\n unigram_counts = dict()\\n token_count = 0\\n ### YOUR CODE HERE\\n raise NotImplementedError\\n ### END YOUR CODE\\n return trigram_counts, bigram_counts, unigram_counts, token_count\",\n \"def compute_vocab_count(sents):\\n counter = collections.Counter()\\n for sentence in sents:\\n counter.update(untag(sentence))\\n return counter\",\n \"def _count_vocab(self,raw_documents, fixed_vocab=False):\\n if fixed_vocab:\\n vocabulary = self.vocabulary_\\n else:\\n # Add a new value when a new vocabulary item is seen\\n vocabulary = defaultdict()\\n vocabulary.default_factory = vocabulary.__len__\\n\\n analyze = super().build_analyzer()\\n \\n j_indices = []\\n indptr = []\\n\\n values = array.array(str('f'))\\n indptr.append(0)\\n for doc in raw_documents:\\n #doc = tupla[0]\\n feature_counter = {}\\n #texttlist = doc.split(sep=\\\" \\\")\\n for feature in analyze(doc):#texttlist:\\n try:\\n \\n # Ignore out-of-vocabulary items for fixed_vocab=True\\n feature_idx = vocabulary[feature]\\n #print(feature_idx)\\n #fti_feature = calc_fti(feature,raw_documents)\\n \\n if feature_idx not in feature_counter:\\n feature_counter[feature_idx] = 1\\n else:\\n feature_counter[feature_idx] += 1\\n #print(feature_counter[feature_idx])\\n except KeyError:\\n # Ignore out-of-vocabulary items for fixed_vocab=True\\n continue\\n\\n\\n j_indices.extend(feature_counter.keys())\\n values.extend(feature_counter.values())\\n indptr.append(len(j_indices))\\n\\n if not fixed_vocab:\\n # disable defaultdict behaviour\\n vocabulary = dict(vocabulary)\\n if not vocabulary:\\n raise ValueError(\\\"empty vocabulary; perhaps the documents only\\\"\\n \\\" contain stop words\\\")\\n\\n if indptr[-1] > np.iinfo(np.int32).max: # = 2**31 - 1\\n if _IS_32BIT:\\n raise ValueError(('sparse CSR array has {} non-zero '\\n 'elements and requires 64 bit indexing, '\\n 'which is unsupported with 32 bit Python.')\\n .format(indptr[-1]))\\n indices_dtype = np.int64\\n\\n else:\\n indices_dtype = np.int32\\n \\n j_indices = np.asarray(j_indices, dtype=indices_dtype)\\n indptr = np.asarray(indptr, dtype=indices_dtype)\\n \\n #print (vocabulary)\\n X = sp.csr_matrix((values, j_indices, indptr),\\n shape=(len(indptr) - 1, len(vocabulary)),\\n dtype=np.float32)\\n X.sort_indices() \\n \\n self.vocabulary_calculated = vocabulary\\n\\n return vocabulary, X\",\n \"def score(self, sentence):\\n # count each incremented word\\n for word in sentence:\\n if word not in self.unigramCounts:\\n self.zeroCount += 1\\n\\n # apply laplace smoothing to unigram model\\n score = 0.0\\n for word in sentence:\\n count = self.unigramCounts[word]\\n score += math.log(count + 1)\\n score -= math.log(self.totalCount + self.zeroCount)\\n return score\",\n \"def add_ngrams(mydict,sentence):\\n ngrams = get_ngrams(sentence,2,3)\\n for ngram in ngrams:\\n if ngram in mydict:\\n mydict[ngram]+=1\\n else:\\n mydict[ngram]=1\\n return mydict\",\n \"def _ngram_counter(self, ngram, ngram_length, text_id, doc):\\n\\n # Only process this ngram is it's punctuation-free (punct --> token.dep == ss.punct) and the 1st / last\\n # words are not stopwords (line mechanics: make a set, look for an intersection with another set)\\n if ([word for word in ngram if word.dep == ss.punct] or\\n {ngram[0].lemma_, ngram[ngram_length - 1].lemma_}.intersection(self.stop_words)):\\n return\\n\\n # Only keep this ngram is it has 1+ nouns in it\\n if len([word for word in ngram if word.pos in self.nouns or word.ent_type in self.entities]) == 0:\\n return\\n\\n ngram_lemma = ' '.join([word.text.lower() if word.lemma_ == '-PRON-' else word.lemma_ for word in ngram])\\n verbatim = ' '.join([word.text.lower() for word in ngram])\\n\\n # add the ngram_lemma to each proximal topic\\n window_start = 0 if ngram[0].i < 7 else ngram[0].i - 7\\n window_end = len(doc) if ngram[0].i + 7 + ngram_length > len(doc) else ngram[0].i + 7 + ngram_length\\n for word in doc[window_start:window_end]:\\n if word.lemma_ in self.topics: # is this a topic we're tracking?\\n # Yes. So let's add it to the subtopic dictionary (with an occurrence count)\\n if ngram_lemma in self.topics[word.lemma_]['subtopics']:\\n self.topics[word.lemma_]['subtopics'][ngram_lemma].add(text_id)\\n else:\\n self.topics[word.lemma_]['subtopics'][ngram_lemma] = {text_id}\\n\\n # TODO: Do I even need self.ngrams anymore? Maybe track everything in the subtopics area?\\n # Keep it! And it's not the first time we've found it.\\n if ngram_lemma in self.ngrams:\\n self.ngrams[ngram_lemma][\\\"count\\\"] += 1\\n self.ngrams[ngram_lemma][\\\"textIDs\\\"] |= {text_id}\\n self.ngrams[ngram_lemma][\\\"verbatims\\\"] |= {verbatim}\\n # Keep it! This is the 1st instance.\\n else:\\n self.ngrams[ngram_lemma] = {\\\"name\\\": ngram_lemma,\\n \\\"count\\\": 1,\\n \\\"textIDs\\\": {text_id},\\n \\\"n\\\": ngram_length,\\n \\\"verbatims\\\": {verbatim},\\n \\\"topic_lemmas\\\": []}\",\n \"def update_words(data, book_num):\\n\\tglobal word_count\\n\\t#find count of each word in the book and update the dictionary\\n\\tfor words in data:\\n\\t\\tword_count[words][book_num] = (word_count.get(words,0)[book_num] + 1)\\n\\t#print(word_count)\",\n \"def train(self, corpus):\\n\\n\\n temp = \\\"\\\"\\n for sentence in corpus.corpus:\\n\\n i = 0\\n for datum in sentence.data:\\n # print str(sentence.data)\\n self.total=self.total+1\\n token = datum.word\\n self.unigramCounts[token] = self.unigramCounts[token] + 1\\n if (i == 0):\\n temp = datum.word\\n i = i + 1\\n continue\\n\\n i = i + 1\\n\\n key = temp + \\\",\\\" + token\\n self.bigramCounts[key] = self.bigramCounts[key] + 1\\n # print token\\n temp = token\\n\\n pass\",\n \"def __init__(self, corpus):\\n self.unigramCounts = collections.defaultdict(lambda: 0)\\n self.totalCount = 0\\n self.zeroCount = 0\\n self.train(corpus)\",\n \"def trigram_model(list_of_words, bigram_count, trigram_count):\\n c_start = list_of_words.count(start_phrase)\\n c_end = list_of_words.count(end_phrase)\\n if c_start == 0:\\n list_of_words.insert(0, start_phrase)\\n list_of_words.insert(0, start_phrase)\\n if c_start == 1:\\n list_of_words.insert(0, start_phrase)\\n if c_end == 0:\\n list_of_words.append(end_phrase)\\n list_of_words.append(end_phrase)\\n if c_end == 1:\\n list_of_words.append(end_phrase)\\n bigram_count = pd.read_csv(bigram_count)\\n trigram_count = pd.read_csv(trigram_count)\\n proba_dict = {list_of_words[i] + \\\" \\\" + list_of_words[i+1] + \\\" \\\" + list_of_words[i+2]:\\n ((trigram_count[list_of_words[i] + \\\" \\\" + list_of_words[i+1] + \\\" \\\" + list_of_words[i+2]].values[0]) /\\n float(bigram_count[list_of_words[i] + \\\" \\\" + list_of_words[i+1]].values[0]))\\n if list_of_words[i] + \\\" \\\" + list_of_words[i+1] + \\\" \\\" + list_of_words[i+2] in trigram_count.columns.values else 0.0 for i in xrange(len(list_of_words) - 2)}\\n return proba_dict\",\n \"def unigram(tokens):\\n model = collections.defaultdict(lambda: 0.01)\\n for token in tokens:\\n try:\\n model[token] += 1\\n except KeyError:\\n model[token] = 1\\n continue\\n for word in model:\\n model[word] = model[word]/float(sum(model.values()))\\n return model\",\n \"def computeTF(self):\\n for word in self.dictionary:\\n self.dictionary[word].setTF(self.getTotalTerms())\",\n \"def train(self, corpus):\\n for sentence in corpus.corpus:\\n cleanSentence = sentence.cleanSentence()\\n for datum in cleanSentence.data:\\n token = datum.word\\n self.unigramCounts[token] = self.unigramCounts[token] + 1\\n self.total += 1\\n\\n i = 0\\n while i < len(sentence.data) - 1:\\n token = str(cleanSentence.get(i))\\n self.followingWords[token].add(str(cleanSentence.get(i+1)))\\n i += 1\\n\\n i = 1\\n while i < len(sentence.data):\\n bigram = str(cleanSentence.get(i-1)) + \\\" \\\" + str(cleanSentence.get(i))\\n self.bigramCounts[bigram] = self.bigramCounts[bigram] + 1\\n\\n self.precedingWords[str(cleanSentence.get(i))].add(str(cleanSentence.get(i-1)))\\n i += 1\\n self.precedingWordsTotal = sum(map(lambda x: len(x), self.precedingWords.values()))\\n\\n i = 2\\n while i < len(sentence.data):\\n trigram = str(cleanSentence.get(i-2)) + \\\" \\\" + str(cleanSentence.get(i-1)) + \\\" \\\" + str(cleanSentence.get(i))\\n self.trigramCounts[trigram] = self.trigramCounts[trigram] + 1\\n i += 1\\n\\n #print('precedingWords')\\n #print(self.precedingWords)\\n #print('followingWords')\\n #print(self.followingWords)\\n #print('unigrams')\\n #print(self.unigramCounts)\\n #print('bigrams')\\n #print(self.bigramCounts)\\n\\n #self.discount(self.trigramCounts)\\n #self.discount(self.bigramCounts)\\n #self.discount(self.unigramCounts)\",\n \"def buildDict(self, dict):\\n self.all_words = set(dict)\\n self.wc_dict = collections.defaultdict(int)\\n for w in dict:\\n for wc in self.get_wildcards(w):\\n self.wc_dict[wc] += 1\",\n \"def __cross_wiki_counts(self):\\n\\n print(\\\"Updating counts by merging with CrossWiki\\\")\\n\\n cnt = 0\\n crosswiki_path = os.path.join(\\n self.base_url, \\\"generic/p_e_m_data/crosswikis_p_e_m.txt\\\"\\n )\\n\\n with open(crosswiki_path, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n for line in f:\\n parts = line.split(\\\"\\\\t\\\")\\n mention = unquote(parts[0])\\n\\n if (\\\"Wikipedia\\\" not in mention) and (\\\"wikipedia\\\" not in mention):\\n if mention not in self.wiki_freq:\\n self.wiki_freq[mention] = {}\\n\\n num_ents = len(parts)\\n for i in range(2, num_ents):\\n ent_str = parts[i].split(\\\",\\\")\\n ent_wiki_id = int(ent_str[0])\\n freq_ent = int(ent_str[1])\\n\\n if (\\n ent_wiki_id\\n not in self.wikipedia.wiki_id_name_map[\\\"ent_id_to_name\\\"]\\n ):\\n ent_name_re = self.wikipedia.wiki_redirect_id(ent_wiki_id)\\n if (\\n ent_name_re\\n in self.wikipedia.wiki_id_name_map[\\\"ent_name_to_id\\\"]\\n ):\\n ent_wiki_id = self.wikipedia.wiki_id_name_map[\\n \\\"ent_name_to_id\\\"\\n ][ent_name_re]\\n\\n cnt += 1\\n if (\\n ent_wiki_id\\n in self.wikipedia.wiki_id_name_map[\\\"ent_id_to_name\\\"]\\n ):\\n if mention not in self.mention_freq:\\n self.mention_freq[mention] = 0\\n self.mention_freq[mention] += freq_ent\\n\\n ent_name = self.wikipedia.wiki_id_name_map[\\n \\\"ent_id_to_name\\\"\\n ][ent_wiki_id].replace(\\\" \\\", \\\"_\\\")\\n if ent_name not in self.wiki_freq[mention]:\\n self.wiki_freq[mention][ent_name] = 0\\n self.wiki_freq[mention][ent_name] += freq_ent\",\n \"def __parse_corpus(self, corpus):\\n corpus = self.__handle_corpus_unkwon_words(corpus)\\n start_token = ' '.join([NGramModel.START_SENTENCE_TOKEN]*(self.__n-1))\\n word_list = corpus.replace(NGramModel.START_SENTENCE_TOKEN, start_token).split()\\n \\n for n in range(1, self.__n+1): \\n self.__ngram_counts[n] = {}\\n for ngram, count in Counter(self.__generate_n_grams(word_list, n)).items():\\n self.__ngram_counts[n][' '.join(ngram)] = count\",\n \"def term_frequency(ngrams,lang):\\n token_dictionary = {}\\n for ng in ngrams:\\n try:\\n token_dictionary[ng] = token_dictionary[ng] + 1\\n except KeyError:\\n token_dictionary[ng] = 1\\n return token_dictionary\",\n \"def add_to_dict(self, tokens):\\n# TODO: ?add normalization of a token?\\n for token in tokens:\\n if self.embedding_words and (token not in self.embedding_words):\\n continue\\n self.freq[token] += 1\\n if token not in self.tok2ind:\\n index = len(self.tok2ind)\\n self.tok2ind[token] = index\\n self.ind2tok[index] = token\",\n \"def count_words(self, contents):\\n wordCounts = {}\\n for i in self.ngramCounts:\\n if i == 0: # want the default to be the size of the corpus\\n total = 0\\n for line in contents:\\n words = line.split(\\\" \\\")\\n words = [ w.strip() for w in words if w] #remove nulls\\n for word in words:\\n if word:\\n total += 1\\n wordCounts[i] = defaultdict(lambda: total)\\n continue\\n else:\\n counts = defaultdict(lambda: 0)\\n for line in contents:\\n words = line.split(\\\" \\\")\\n words = [ w.strip() for w in words if w] #remove nulls\\n for k, word in enumerate(words): \\n if k < (i-1) or not word:\\n continue\\n key = \\\"\\\"\\n for j in range(k-i+1, k+1):\\n key += words[j] + \\\" \\\"\\n counts[key.strip()] += 1\\n wordCounts[i] = counts\\n return wordCounts\",\n \"def convert_word_to_count(counter={}, doc=[]):\\n for sentence in doc:\\n for word in sentence.split():\\n if word not in counter:\\n counter[word] = 1\\n else:\\n counter[word] += 1\\n return counter\",\n \"def count_words_and_dublicates(novel):\",\n \"def __init__(self, n, sents):\\n assert n > 0\\n self._n = n\\n print(\\\"Counting...\\\")\\n count = defaultdict(int)\\n while n >= 0:\\n for sent in sents:\\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\\n s.insert(0, \\\"<s>\\\")\\n s.append(\\\"</s>\\\")\\n for i in range(len(s) - n + 1):\\n count[tuple(s[i:i + n])] += 1\\n n -= 1\\n count[()] = count[()] - count[('<s>',)] - count[\\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\\n self._count = count\\n print(\\\"Computing vocabulary...\\\")\\n self._voc = voc = set()\\n for sent in sents:\\n voc = voc.union(set(sent))\\n voc.add('</s>')\\n self._voc = voc\\n self._V = len(voc) # vocabulary size\\n print(\\\"Done\\\")\",\n \"def get_counts(data):\\n\\n word_count = {}\\n syll_count = {}\\n\\n infile = data.corpus\\n try:\\n\\n open_file = codecs.open(infile, 'r', encoding='utf-16')\\n for line in open_file:\\n line = line.lower()\\n # Remove tablet indexing info and line numbers. Grab only text data\\n line = line.split(',')\\n text = clean_line(line[7])\\n\\n # Update the occurrences of the words in the line\\n for word in text.split():\\n count = word_count.setdefault(word, 0)\\n word_count[word] = count + 1\\n\\n # Track occurrences of syllables\\n update_syllable_count(word, syll_count)\\n\\n open_file.close()\\n except IOError:\\n print(\\\"Cannot open: \\\" + infile)\\n\\n return (word_count, syll_count)\",\n \"def update_vocab(self, text):\\n for char in text:\\n if char not in self.vocab:\\n self.vocab[char] = len(self.vocab)\\n if char not in self.char2count:\\n self.char2count[char] = 0\\n self.char2count[char] += 1\\n return\",\n \"def phrase_scoring_ranking(phrases,model,dataset,bitext):\\n e_phrases = []\\n f_phrases = []\\n count = 0\\n f_phrase_count = {}\\n e_phrase_count = {} #not needed\\n #e_f_pair_count = {} #e words as rows and f words as columns\\n f_e_pair_count = {} #e words as rows and f words as columns\\n for phrase_set in phrases:\\n for phrase in phrase_set:\\n e_phrases.append(phrase[3])\\n f_phrases.append(phrase[2])\\n if phrase[2] in f_phrase_count:\\n f_phrase_count[phrase[2]] += 1\\n else:\\n f_phrase_count[phrase[2]] = 1\\n if phrase[2] in f_e_pair_count:\\n if phrase[3] in f_e_pair_count[phrase[2]]:\\n f_e_pair_count[phrase[2]][phrase[3]] += 1\\n else:\\n f_e_pair_count[phrase[2]][phrase[3]] = 1\\n else:\\n f_e_pair_count[phrase[2]]={}\\n f_e_pair_count[phrase[2]][phrase[3]] = 1\\n\\n e_phrases = list(set(e_phrases))\\n f_phrases = list(set(f_phrases))\\n ep_count = len(e_phrases)\\n fp_count = len(f_phrases)\\n #pmatrix = np.empty(ep_count*fp_count) # ######Not needed if dictionary is used\\n #pmatrix = pmatrix.reshape(ep_count,fp_count)\\n #pmatrix.fill(0)\\n ef_prob_dict = {}\\n for e in e_phrases:\\n for f in f_phrases:\\n ef_count =count_fe_pair(e,f,f_e_pair_count)# f_e_pair_count[e][f]\\n f_count = f_phrase_count[f]\\n e_idx = e_phrases.index(e) ###Check the count logic again\\n f_idx = f_phrases.index(f)\\n pair_prob = ef_count/f_count\\n #pmatrix[e_idx][f_idx] = pair_prob\\n if f in f_e_pair_count:\\n if e in f_e_pair_count[f]:\\n if f in ef_prob_dict:\\n ef_prob_dict[f][e]=pair_prob\\n else:\\n ef_prob_dict[f] = {}\\n ef_prob_dict[f][e] = pair_prob\\n\\n #if pmatrix[e_idx][f_idx] != 0:\\n # print(e,f,ef_count,f_count,pair_prob)\\n return ef_prob_dict\",\n \"def score(self, sentence):\\n\\n score = 0.0\\n i = 0\\n temp = \\\"\\\"\\n for token in sentence:\\n count = self.unigramCounts[token]\\n if (i == 0):\\n i = i + 1\\n temp = token\\n continue\\n\\n key = temp + \\\",\\\" + token\\n bicount = self.bigramCounts[key]\\n unicount = self.unigramCounts[temp]\\n temp = token\\n if bicount > 0 :\\n\\n score += (math.log(bicount) - math.log(unicount))\\n else:\\n unicount = self.unigramCounts[token]\\n score += math.log(unicount + 1) + math.log(0.4)\\n score -= math.log(self.total + len(self.unigramCounts))\\n\\n return score\",\n \"def construct_ngrams_dict(ngrams_list):\\n counts = {}\\n\\n for t in ngrams_list:\\n key = hash_function(t)\\n if key in counts:\\n counts[key] += 1\\n else:\\n counts[key] = 1\\n return counts\",\n \"def countize(word, ind, count_words, features):\\n word = clean(word)\\n word = word.split()\\n if len(word)>1:\\n for i in range(1,len(word)):\\n bigram = (word[i-1],word[i])\\n count_words[ind].append(bigram)\\n features.append(bigram)\\n if len(word)>2:\\n for i in range(2,len(word)):\\n trigram = (word[i-2],word[i-1], word[i])\\n count_words[ind].append(trigram)\\n features.append(trigram)\\n for i in range(len(word)):\\n unigram = word[i]\\n count_words[ind].append((unigram))\\n features.append((unigram))\\n return count_words, features\",\n \"def calc_tf(doc):\\r\\n tf = {}\\r\\n for term in doc:\\r\\n if term not in tf:\\r\\n tf[term] = doc.count(term)\\r\\n return tf\",\n \"def get_frequencies(tokens):\\n cnt = {}\\n\\n for word in tokens:\\n if word not in cnt:\\n cnt[word] = 0\\n\\n cnt[word] += 1\\n\\n return cnt\",\n \"def set_grams(data_path,top=100):\\n files = glob.glob(data_path + \\\"/*/*word*.txt\\\") # txt files in subfolders\\n ngram = []\\n table = str.maketrans(\\\"\\\",\\\"\\\",string.punctuation)\\n for f_in in files:\\n with open(f_in, 'r') as fi:\\n for lines in fi:\\n item = lines.replace(\\\"\\\\n\\\",\\\"\\\").split()\\n term = \\\"\\\"\\n count = 0\\n if len(item)==3: # bigrams\\n term0 = str(item[0]).translate(table).strip()\\n term1 = str(item[1]).translate(table).strip()\\n term = \\\"{},{}\\\".format(term0,term1) if (len(term0)>2 and len(term1)>2 and not term0.isnumeric() and not term1.isnumeric()) else (term0 if (len(term0)>2 and not term0.isnumeric()) else (term1 if (len(term1)>2 and not term1.isnumeric()) else \\\"\\\")) # comma(,) for OR in Twitter \\n count = int(item[2])\\n elif len(item)==2: # unigrams\\n term = str(item[0]).translate(table).strip()\\n count = int(item[1])\\n if count>=top and str(term) != 'nan' and len(term)>=3: # ignore term freq minor than top and term length than 3\\n ngram.append(term)\\n fi.close()\\n gn_set = set(ngram)\\n \\n print(len(gn_set))\\n \\n f = open(data_path+\\\".txt\\\", 'w')\\n for w in gn_set:\\n f.write('{}\\\\n'.format(w))\\n f.close()\\n \\n return list(gn_set)\",\n \"def computeWordFrequencies(self, tokens: ['token'], frequencies: {'token': int}):\\n # project2: update this method to take existing dict as parameter and modify it\\n # additionally, stopwords are not inserted in the dict;\\n # words shorter than 3 character or contains all digits are ignored\\n for token in tokens:\\n # if the key is not in dict, dict.setdefault method initiates the value at 0\\n # if token not in stopwords and len(token) >= 3 and not token.isdigit():\\n frequencies[token] = frequencies.setdefault(token, 0) + 1\",\n \"def _collect_counts(self):\\n for t in self.system.keys():\\n if t in self.gold:\\n self.tp += 1\\n else:\\n self.fp += 1\\n for t in self.gold.keys():\\n if t not in self.system:\\n self.fn += 1\",\n \"def frequencies(corpus, index, to_lower=False):\\n freq = {}\\n for sentence in corpus.get_sentences():\\n for word in sentence:\\n key = word[index]\\n if to_lower:\\n key = key.lower()\\n if key in freq:\\n freq[key] += 1\\n else:\\n freq[key] = 1\\n\\n return freq\",\n \"def build_ngram_index(tokenized_documents, ngrams):\\n dictionary = {}\\n\\n doc_ngrams = {}\\n for doc in tokenized_documents:\\n ngrams_freq = {}\\n\\n measures = nltk.collocations.BigramAssocMeasures()\\n finder = BigramCollocationFinder.from_words(tokenized_documents[doc])\\n freqs = finder.ngram_fd\\n for ngram in freqs:\\n ngrams_freq[ngram] = freqs[ngram]\\n \\n measures = nltk.collocations.TrigramAssocMeasures()\\n finder = TrigramCollocationFinder.from_words(tokenized_documents[doc])\\n freqs = finder.ngram_fd\\n for ngram in freqs:\\n ngrams_freq[ngram] = freqs[ngram]\\n\\n doc_ngrams[doc] = ngrams_freq\\n\\n for ngram in ngrams:\\n dictionary[ngram] = [0]\\n for doc in doc_ngrams:\\n if ngram in doc_ngrams[doc]:\\n dictionary[ngram][0] += doc_ngrams[doc][ngram]\\n dictionary[ngram].append((doc, doc_ngrams[doc][ngram]))\\n \\n return dictionary\",\n \"def train(self, iterable):\\n for ngram in generate_ngrams(iterable, self.n + 1):\\n self.markov_dict.setdefault(ngram[: self.n], Counter()).update([ngram[self.n]])\\n self.prob_dict.update([ngram[: self.n]])\",\n \"def count_terms(self, tokens):\\n\\n terms = [self.term_match(t) for t in tokens ]\\n \\n terms = [t for t in terms if t != None]\\n\\n #print terms\\n lf = dict(Counter(terms))\\n for k in lf:\\n lf[k] /= float(len(tokens))\\n #lf[k] = 1 # binarize?\\n pass\\n return lf\",\n \"def compute_frequencies(num_words, documents):\\n res = [0 for i in range(num_words)]\\n sum = 0\\n for word in documents:\\n sum += 1\\n tmp = set(word)\\n for number in tmp:\\n res[number] += 1\\n \\n res = [i / sum for i in res]\\n return res\",\n \"def count_doc_frequencies(self, docs):\\n frequencyIndex = {}\\n doc_id = 0\\n for doc in docs:\\n for term in doc:\\n if term not in frequencyIndex:\\n frequencyIndex[term] = [doc_id]\\n else:\\n for id in frequencyIndex[term]:\\n if doc_id == id:\\n break\\n else:\\n frequencyIndex[term].append(doc_id)\\n doc_id+=1\\n\\n for term in frequencyIndex:\\n occurences = len(frequencyIndex[term])\\n frequencyIndex[term] = occurences\\n\\n return frequencyIndex\",\n \"def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) -> Counter:\\n ngram_counter: Counter = Counter()\\n\\n for i in range(1, n_gram + 1):\\n for j in range(len(ngram_input_list) - i + 1):\\n ngram_key = tuple(ngram_input_list[j : (i + j)])\\n ngram_counter[ngram_key] += 1\\n\\n return ngram_counter\",\n \"def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) ->Counter:\\n ngram_counter: Counter = Counter()\\n for i in range(1, n_gram + 1):\\n for j in range(len(ngram_input_list) - i + 1):\\n ngram_key = tuple(ngram_input_list[j:i + j])\\n ngram_counter[ngram_key] += 1\\n return ngram_counter\",\n \"def _update_triad_counts(self):\\n for i in range(len(self.learning_string) - 3):\\n triad = self.learning_string[i] + self.learning_string[i + 1] + self.learning_string[i + 2]\\n\\n if self.learning_string[i + 3] == '0':\\n self.triad_counts[triad][0] += 1\\n elif self.learning_string[i + 3] == '1':\\n self.triad_counts[triad][1] += 1\\n\\n return\",\n \"def add_unique_word_count(self):\\n call_count = lambda letter_: self._count_unique_words(letter_)\\n self.dataframe['unique_words'] = self.dataframe['letter'].map(call_count)\",\n \"def update_word_stats(self, tweet):\\n\\n if not self.text:\\n return\\n\\n words = self.text.split()\\n\\n # process single words\\n for word in words:\\n self.update_stats('words', word)\\n\\n # process 2 word lists\\n pairs = self.get_phrase_list(words, 2)\\n if pairs is not None:\\n for word_pair in pairs:\\n self.update_stats('word_pairs', self.get_index_from_list(word_pair))\\n\\n # process 3 word lists\\n triples = self.get_phrase_list(words, 3)\\n if triples is not None:\\n for word_triple in triples:\\n self.update_stats('word_triples', self.get_index_from_list(word_triple))\",\n \"def add(counts):\\n if counts:\\n for k in grammar.keys():\\n grammar[k] = grammar[k] + counts[k]\",\n \"def num_bigram(doc):\\n matched_spans = []\\n matches = matcher(doc)\\n for match_id, start, end in matches:\\n span = doc[start:end]\\n matched_spans.append(span)\\n for span in matched_spans: # merge into one token after collecting all matches\\n span.merge()\\n return doc\",\n \"def preprocess(self, documents):\\n\\n # A dict storing the frequency of each word\\n word_freq = {}\\n\\n # Iterate for each document\\n for doc in documents:\\n # Split the document into a list of words and iterate on it\\n for w in extract_words(doc):\\n # Update word frequencies\\n '''YOUR CODE HERE'''\\n if w not in word_freq.keys():\\n word_freq[w] = 1\\n else:\\n word_freq[w] += 1\\n\\n ''' END CODE FOR THIS LOOP '''\\n\\n\\n # A set of words with frequency less than 'self.min_freq'\\n remove_words = set()\\n\\n # Check frequency of each word and add to 'remove_words'\\n # if it's frequency is below self.min_freq\\n\\n ''' YOUR CODE HERE '''\\n for w in word_freq.keys():\\n if word_freq[w] < self.min_freq:\\n remove_words.add(w)\\n\\n # Delete the words in 'remove_words' from 'word_freq'\\n for w in remove_words:\\n del word_freq[w]\\n\\n # Fill 'self.word_to_idx' and 'self.idx_to_word' for\\n # each word in 'word_freq' (dicts are explained above)\\n\\n i = 0\\n for w in word_freq.keys():\\n self.word_to_idx[w] = i\\n self.idx_to_word[i] = w \\n i += 1\\n\\n ''' END YOUR CODE HERE '''\",\n \"def test_fill_in_dic():\\n ngrams = NgramFrequencies()\\n word_per_list = [\\\"time\\\", \\\"burton's\\\", \\\"corpse\\\", \\\"bride\\\"]\\n ngrams.fill_in_dic(word_per_list)\\n assert ngrams.unigrams_dic == {\\n \\\"COUNT\\\": 4,\\n \\\"time\\\": 1,\\n \\\"burton's\\\": 1,\\n \\\"corpse\\\": 1,\\n \\\"bride\\\": 1\\n }\\n assert ngrams.bigrams_dic == {\\n \\\"COUNT\\\": 3,\\n \\\"time_burton's\\\": 1,\\n \\\"burton's_corpse\\\": 1,\\n \\\"corpse_bride\\\": 1\\n }\\n assert ngrams.trigrams_dic == {\\n \\\"COUNT\\\": 2,\\n \\\"time_burton's_corpse\\\": 1,\\n \\\"burton's_corpse_bride\\\": 1\\n }\",\n \"def unigram_model(list_of_words, unigram_count, N=count_token()):\\n d = pd.read_csv(unigram_count)\\n proba_dict = {list_of_words[i]: (d[el].values[0] / float(N)) if el in d.columns.values else 0.0 for i, el in enumerate(list_of_words) }\\n return proba_dict\",\n \"def __init__(self, corpus):\\n self.total = 0\\n self.reverseBigramCount = defaultdict(lambda : defaultdict(lambda : 0))\\n self.bigramCount = defaultdict(lambda : defaultdict(lambda : 0))\\n self.unigramCount = defaultdict(lambda: 0)\\n self.train(corpus)\",\n \"def process_family_frequencies(self, parent, family):\\n if not family:\\n return None\\n counts = {}\\n n_tokens = 0\\n for description_array in family:\\n seen = set([])\\n for token in description_array:\\n counts[token] = counts.get(token, 0) + 1\\n n_tokens += 1\\n\\n self.word2tf[token] = self.word2tf.get(token, 0) + 1\\n self.n_words += 1\\n if token not in seen:\\n self.word2df[token] = self.word2df.get(token, 0) + 1\\n seen.add(token)\\n\\n self.family2tf[parent] = {tok: count/n_tokens for tok, count in counts.items()}\\n self.data.extend(family)\\n return True\",\n \"def frequencies(self):\\n dic = {}\\n for word in self.words():\\n dic[word] = dic.get(word, 0) + 1\\n return dic\",\n \"def countFreq(self,document):\\n self.document = document\\n vocab=['python','js','android','php','django','javascript','oracle','ruby','rails','java']\\n cnt_vector = CountVectorizer(vocabulary=vocab)\\n self.freq_term_matrix = cnt_vector.fit_transform(self.document)\\n return self.freq_term_matrix.toarray()\",\n \"def _count_occurrences(self, corpus_tokens: list, window_size: int):\\n ngram_occurrences = {}\\n for i, corpus_token in enumerate(corpus_tokens):\\n ngram = []\\n if i + window_size > len(corpus_tokens) - 1:\\n break\\n else:\\n for j in range(window_size):\\n ngram.append(corpus_tokens[i + j])\\n if self.TOKENS.END.value in ngram:\\n continue\\n else:\\n ngram_key = tuple(ngram)\\n if ngram_key in ngram_occurrences:\\n ngram_occurrences[ngram_key] += 1\\n else:\\n ngram_occurrences[ngram_key] = 1\\n return ngram_occurrences\",\n \"def make_word_to_freq(self):\\n\\t\\tword_to_freq = {}\\n\\t\\tdocuments = self.tokenized_documents[\\\"train\\\"]\\n\\t\\tfor document in documents:\\n\\t\\t\\tfor word in document:\\n\\t\\t\\t\\tif not word in self.worddict: # make sure we have not found one of the pre-defined words\\n\\t\\t\\t\\t\\tword_to_freq[word] = word_to_freq.get(word, 0) + 1\\n\\t\\t\\n\\t\\treturn word_to_freq\",\n \"def train(self, corpus): \\n # TODO your code here\\n # Tip: To get words from the corpus, try\\n # for sentence in corpus.corpus:\\n # for datum in sentence.data: \\n # word = datum.word\\n for sentence in corpus:\\n prevWord = \\\"\\\"\\n prevPrevWord = \\\"\\\"\\n for word in sentence:\\n word = word.strip(STRIP_CHARS)\\n word = word.lower()\\n currentWord = word\\n self.unigramCounts[currentWord] += 1\\n self.total += 1\\n if prevWord != \\\"\\\":\\n if prevPrevWord != \\\"\\\":\\n trigram = (prevPrevWord, prevWord, currentWord)\\n if trigram not in self.trigramCounts:\\n self.continuationCounts[currentWord] += 1\\n self.followingCounts[(prevPrevWord, prevWord)] += 1\\n self.trigramCounts[trigram] += 1\\n self.bigramCounts[(prevWord, currentWord)] += 1\\n self.totalBigramCounts += 1\\n else:\\n self.bigramCounts[(prevWord, currentWord)] += 1\\n self.totalBigramCounts += 1\\n prevPrevWord = prevWord\\n prevWord = currentWord\\n else:\\n prevWord = currentWord\\n self.total += len(self.unigramCounts)\",\n \"def create_freq_dict(corpus, doc_info):\\n for idx, content in enumerate(corpus):\\n word_freq_table = {}\\n splitted_sentence = content.split()\\n for word in splitted_sentence:\\n word = word.lower()\\n if word not in word_freq_table:\\n word_freq_table[word] = 1\\n else:\\n word_freq_table[word] += 1\\n doc_info[idx]['freq_dict'] = word_freq_table\",\n \"def count_n_grams(data, n, start_token='<s>', end_token = '<e>'):\\r\\n \\r\\n # Initialize dictionary of n-grams and their counts\\r\\n n_grams = {}\\r\\n\\r\\n \\r\\n for sentence in data: # complete this line\\r\\n \\r\\n # prepend start token n times, and append <e> one time\\r\\n sentence = [start_token]*n + sentence + [end_token]\\r\\n \\r\\n # convert list to tuple\\r\\n # So that the sequence of words can be used as\\r\\n # a key in the dictionary\\r\\n sentence = tuple(sentence)\\r\\n\\r\\n \\r\\n for i in range(len(sentence)+1-n): # complete this line\\r\\n\\r\\n # Get the n-gram from i to i+n\\r\\n n_gram = sentence[i:i+n]\\r\\n\\r\\n # check if the n-gram is in the dictionary\\r\\n if n_gram in n_grams: \\r\\n \\r\\n # Increment the count for this n-gram\\r\\n n_grams[n_gram] += 1\\r\\n else:\\r\\n # Initialize this n-gram count to 1\\r\\n n_grams[n_gram] = 1\\r\\n \\r\\n return n_grams\",\n \"def addUnigrams(self, rating, writtenReview):\\n sentence = writtenReview.split()\\n for word in sentence:\\n if word not in self.dictionary:\\n self.addItem(word)\\n self.totalTerms[rating] += 1\\n self.dictionary[word].incrementFrequency(rating)\",\n \"def count(self):\\n freq = {}\\n\\n for desc in self.words:\\n if desc in freq:\\n freq[desc] += 1\\n else:\\n freq[desc] = 1\\n\\n return freq\",\n \"def normalize(self):\\n for key in self.corpus.keys():\\n sum_count = 0\\n words = []\\n counts = []\\n for k, v in self.corpus[key].items():\\n sum_count += v\\n words.append(k)\\n counts.append(v)\\n prob = [float(count)/sum_count for count in counts]\\n\\n self.corpus[key] = [words, prob]\",\n \"def increment_count(self, word):\\n pass\",\n \"def train(self, documents):\\n ###DONE\\n\\n #entire vocab in document set D\\n vocab_sod = set()\\n vocab_pop = set()\\n \\n #Calcuates prior probabilities\\n priorSOD = 0 #how many docs are spam\\n priorPOP = 0 #how many docs are ham\\n \\n #Cacluates Tct\\n term_freq_sod = {} #{term:occur, term:occur}\\n term_freq_pop = {}\\n \\n #Tct'\\n Tct_sod = 0 #Tct' = sum of (every term occurence in class c + 1)\\n Tct_pop = 0\\n \\n for doc in documents: \\n if 'sod' in doc.label:\\n priorSOD += 1\\n for token in doc.tokens:\\n Tct_sod += 1\\n if token in term_freq_sod.keys():\\n term_freq_sod[token] = term_freq_sod[token] + 1\\n else:\\n term_freq_sod[token] = 1\\n vocab_sod.add(token) \\n else:\\n priorPOP += 1\\n for token in doc.tokens:\\n Tct_pop += 1\\n if token in term_freq_pop.keys():\\n term_freq_pop[token] = term_freq_pop[token] + 1\\n else:\\n term_freq_pop[token] = 1\\n vocab_pop.add(token)\\n \\n \\n #endfor\\n # | is for set join\\n self.vocab = vocab_sod | vocab_pop #gets rid of duplicate words (those in both 'ham' and 'spam') \\n \\n #Tct Primes\\n #tct' = term freq of all terms in class c + 1*(total terms)\\n Tct_sod = Tct_sod + len(self.vocab) \\n Tct_pop = Tct_pop + len(self.vocab) \\n \\n \\n print(\\\"PriorSod: \\\" + str(priorSOD))\\n print(\\\"PriorPop: \\\" + str(priorPOP))\\n print(\\\"LEN Docum: \\\" + str(len(documents)))\\n \\n self.priorSOD = priorSOD / len(documents)\\n self.priorPOP = priorPOP / len(documents)\\n \\n for term in self.vocab:\\n if term in term_freq_pop.keys():\\n self.cond_prob_pop[term] = (term_freq_pop[term] + 1) / Tct_pop\\n else:\\n self.cond_prob_pop[term] = 1 / Tct_pop\\n \\n if term in term_freq_sod.keys():\\n self.cond_prob_sod[term] = (term_freq_sod[term] + 1) / Tct_sod\\n else:\\n self.cond_prob_sod[term] = 1 / Tct_sod\\n \\n \\n pass\",\n \"def _profile(self, text):\\n prof = zeros(len(self.alph)**self.N)\\n ngs = ngrams(text, self.N)\\n for tup in ngs:\\n loc = 0\\n for i in range(len(tup)):\\n loc += (len(self.alph)**i) * self.alph.index(tup[i])\\n prof[loc] += 1\\n return prof\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7613877","0.754076","0.7213328","0.7121193","0.7052331","0.6792219","0.6738704","0.6667053","0.6502214","0.6489286","0.647944","0.64368546","0.6427307","0.641034","0.6370047","0.6328885","0.6313854","0.62974036","0.62933725","0.6273226","0.62302506","0.620344","0.6201586","0.61865443","0.6184886","0.6174701","0.6172101","0.61720663","0.61524993","0.6150279","0.6138737","0.6106462","0.60801256","0.608004","0.6072656","0.6045799","0.6040158","0.6036199","0.60251707","0.6019934","0.6002051","0.5982376","0.5963565","0.59607244","0.5948909","0.59434664","0.5939282","0.59319854","0.5919459","0.5908679","0.59001756","0.5899315","0.5885471","0.58834314","0.587003","0.58604","0.58514124","0.58501804","0.58459085","0.5839745","0.5827479","0.5822862","0.58196324","0.58172333","0.5813798","0.58071655","0.57956904","0.5786258","0.57798874","0.5779528","0.57774484","0.5775167","0.5771084","0.5766596","0.57590085","0.57500756","0.57495767","0.5735988","0.5730348","0.57278323","0.5723526","0.5722045","0.57175094","0.57131106","0.57128155","0.56992954","0.56965315","0.56926936","0.5691096","0.56903625","0.5688576","0.5681426","0.5681333","0.56788903","0.567876","0.5673987","0.56721693","0.56712574","0.5667831","0.56618315","0.5659215"],"string":"[\n \"0.7613877\",\n \"0.754076\",\n \"0.7213328\",\n \"0.7121193\",\n \"0.7052331\",\n \"0.6792219\",\n \"0.6738704\",\n \"0.6667053\",\n \"0.6502214\",\n \"0.6489286\",\n \"0.647944\",\n \"0.64368546\",\n \"0.6427307\",\n \"0.641034\",\n \"0.6370047\",\n \"0.6328885\",\n \"0.6313854\",\n \"0.62974036\",\n \"0.62933725\",\n \"0.6273226\",\n \"0.62302506\",\n \"0.620344\",\n \"0.6201586\",\n \"0.61865443\",\n \"0.6184886\",\n \"0.6174701\",\n \"0.6172101\",\n \"0.61720663\",\n \"0.61524993\",\n \"0.6150279\",\n \"0.6138737\",\n \"0.6106462\",\n \"0.60801256\",\n \"0.608004\",\n \"0.6072656\",\n \"0.6045799\",\n \"0.6040158\",\n \"0.6036199\",\n \"0.60251707\",\n \"0.6019934\",\n \"0.6002051\",\n \"0.5982376\",\n \"0.5963565\",\n \"0.59607244\",\n \"0.5948909\",\n \"0.59434664\",\n \"0.5939282\",\n \"0.59319854\",\n \"0.5919459\",\n \"0.5908679\",\n \"0.59001756\",\n \"0.5899315\",\n \"0.5885471\",\n \"0.58834314\",\n \"0.587003\",\n \"0.58604\",\n \"0.58514124\",\n \"0.58501804\",\n \"0.58459085\",\n \"0.5839745\",\n \"0.5827479\",\n \"0.5822862\",\n \"0.58196324\",\n \"0.58172333\",\n \"0.5813798\",\n \"0.58071655\",\n \"0.57956904\",\n \"0.5786258\",\n \"0.57798874\",\n \"0.5779528\",\n \"0.57774484\",\n \"0.5775167\",\n \"0.5771084\",\n \"0.5766596\",\n \"0.57590085\",\n \"0.57500756\",\n \"0.57495767\",\n \"0.5735988\",\n \"0.5730348\",\n \"0.57278323\",\n \"0.5723526\",\n \"0.5722045\",\n \"0.57175094\",\n \"0.57131106\",\n \"0.57128155\",\n \"0.56992954\",\n \"0.56965315\",\n \"0.56926936\",\n \"0.5691096\",\n \"0.56903625\",\n \"0.5688576\",\n \"0.5681426\",\n \"0.5681333\",\n \"0.56788903\",\n \"0.567876\",\n \"0.5673987\",\n \"0.56721693\",\n \"0.56712574\",\n \"0.5667831\",\n \"0.56618315\",\n \"0.5659215\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3196,"cells":{"query":{"kind":"string","value":"Clean a line of data, removing all annotations from the line."},"document":{"kind":"string","value":"def clean_line(line, normNum=True, normProf=True):\n\n # Remove square brackets, ceiling characters, question marks, other\n # questionable characters, and line breaks\n line = re.sub(r'(\\[|\\])', '', line)\n line = re.sub(r'(⌈|⌉)', '', line)\n line = re.sub(r'( / )', ' ', line)\n line = re.sub(r'/', '', line)\n line = re.sub(r'\\?', '', line)\n line = re.sub(r'([<]|[>])+', '', line)\n line = re.sub(r'!', '', line)\n line = re.sub(r'\"', '', line)\n\n # Remove researcher's notes, and multiple dashes or '='s\n line = re.sub(r'(\\(.*\\))', '', line)\n line = re.sub(r'(#[.]*)', '', line)\n line = re.sub(r'[-]{2}', '', line)\n line = re.sub(r'[=]{2}', '', line)\n\n # Replace numbers with 'number'\n if normNum is True:\n line = re.sub(r'\\b(?<!-)(\\d+)(?![\\w-])', 'number', line)\n line = re.sub(r'[-+]?\\b\\d+\\b', 'number', line)\n\n #line = re.sub(r'\\b([\\-\\.0-9]+)(?![\\w-])', 'number', line)\n\n # Replace professions with 'profession'\n if normProf is True:\n line = professions.replaceProfessions(line)\n\n # Remove blank character at end of line\n linelength = len(line)\n if (linelength > 0 and line[linelength-1] == \"\"):\n del line[0:linelength-2]\n\n return line"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def cleaning (data):","def clean_line(self, line):\n\n if \"#\" in line:\n temp = line.split(\"#\")\n if len(temp) < 2:\n return \"\"\n else:\n temp = temp[0] + \"\\n\"\n\n # make sure the \"#\" isn't in quotes\n if temp.count(\"\\\"\") % 2 == 0:\n line = temp\n\n line = line.replace(\"}\", \" } \").replace(\"{\", \" { \")\n while \"=\" in line:\n line = self.replace_equals(line)\n line = line.lstrip()\n return line","def remove_code_annotations(line_to_transform):\n line_to_transform = str(line_to_transform)\n line_to_transform = line_to_transform.split(' #', 1)[0]\n line_to_transform = line_to_transform.replace(':', '')\n line_to_transform = line_to_transform.replace('\\t', '')\n line_to_transform = line_to_transform.replace(' ', '')\n line_to_transform = line_to_transform.replace('\\n', '')\n line_to_transform = line_to_transform.replace('elif ', '')\n line_to_transform = line_to_transform.replace('if ', '')\n line_to_transform = line_to_transform.replace('else ', '')\n line_to_transform = line_to_transform.replace('else', '')\n line_to_transform = line_to_transform.replace('def ', '')\n line_to_transform = line_to_transform.replace('for ', '')\n line_to_transform = line_to_transform.replace('while ', '')\n return line_to_transform","def __clean_line_comments(self):\n self.lines = [l for l in self.lines if not l.startswith(\"//\") and len(l) != 0]","def __clean_line_comments(self):\n self.lines = [l for l in self.lines if not l.startswith(\"//\") and len(l) != 0]","def clean_data(self):\n for line in self.file:\n if line.startswith('//') or line.isspace():\n continue\n if '//' in line:\n line = line.split('//')[0]\n line = line.replace('\\n', '')\n line = line.replace(' ','')\n self.commands.append(line)","def cut_line(self):\r\n self.parachute.pop(0)","def setCleanAnnotations(self, value):\n return self._set(cleanAnnotations=value)","def mapper_data_cleaning(self, l, line):\n lineitems = line.split(\",\")\n yield (lineitems[0], lineitems[2])","def clean(c):","def delTcline(self, line):\n self._checkfigure()\n ld = self._get_linedict(line)\n for vline in ld['vlines']:\n vline.remove()\n ld['vlines'] = []","def strip_line(line):\n line = line.strip()\n line = line.rstrip('\\n')\n line = line.rstrip('\\t')\n line = (line.split(\"//\"))[0]\n return line","def FilterLine(self, a_line):\n return a_line","def strip_warnings(self, line):\n if line[0] == \"|\":\n return \"\"\n else:\n return line","def delete_line(self, line):\n self._checkfigure()\n ld = self._get_linedict(line)\n self.delTcline(ld)\n line = ld['line']\n line.remove()\n self.lines.remove(ld)","def test__clean_line():\n LINES = {\n \"One morn before me were three figures seen,\":\n \"One morn before me were three figures seen,\",\n \"And once—more came they by:-alas! wherefore?\":\n \"And once more came they by: alas! wherefore?\",\n }\n for line, clean_line in LINES.items():\n assert(LineBuilder(line)._clean_line() == clean_line)","def clean(self, line):\r\n m = self.RE.match(line)\r\n if line.strip() == \">\":\r\n return \"\"\r\n elif m:\r\n return m.group(2)\r\n else:\r\n return line","def remove_lines():\n work_folder = os.path.join(CURRENT_FOLDER, \"..\\\\Data\\\\weather_data\")\n with open(os.path.join(work_folder, \"filtered_merged_history_KMDW.csv\"), \"w\") as outfile:\n with open(os.path.join(work_folder, \"merged_history_KMDW.csv\")) as infile:\n outfile.write(infile.next())\n for line in infile:\n if line[0].isdigit():\n outfile.write(line)","def clean(self, line):\n m = self.RE.match(line)\n if line.strip() == \">\":\n return \"\"\n elif m:\n return m.group(2)\n else:\n return line","def rstrip_line(line):\n return line.rstrip()","def clean_chunk(chunk):\n return '\\n'.join([x[1:] for x in chunk.split('\\n')\n if x and x[0] not in ('-', '@')])","def clean(line):\n line = line.lower().replace(\"\\n\",\" \").replace(\"\\r\",\"\").replace(',',\"\").replace(\">\",\"> \").replace(\"<\", \" <\").replace(\"|\",\" \")\n return line","def process(lines):\n lines = list(map(_clean, lines))\n # lines = list(map(_split, lines))\n return lines","def removeAnnotation(self,i=0):\n #print \"REMOVE %s\" % i\n map(undraw,self._annotations[i])\n del self._annotations[i]","def RemoveMarker(self, marker, line):\n assert isinstance(marker, ed_marker.Marker)\n marker.Set(self, line, delete=True)","def unhighlight_line(self, line):\n self._checkfigure()\n ld = self._get_linedict(line)\n ld['highlighted'] = False\n self.update_lines()","def clean(text):\n lines = text.split('\\n')\n\n indx = range(len(lines))\n indx.reverse()\n for i in indx:\n temp = lines[i].strip()\n if temp == '' or temp.startswith('#'):\n del lines[i]\n else:\n lines[i] = temp\n\n return lines","def _clean_data(self, dataset):\n dataset.dropna(inplace=True)\n # Problem: handle missing data (in a different way), noisy data, inconsistent data","def list_strip(line: list):\n new_line = [field.strip() for field in line]\n if new_line != line:\n tpl = \"Removed trailing whitespaces in fields of line: {}\"\n msg = tpl.format(line)\n warnings.warn(msg, ParseIsatabWarning)\n return new_line","def clean_lines(lines):\n _lines = []\n for l in lines:\n l = l.strip().rstrip()\n if len(l) > 0:\n _lines.append(l)\n return _lines","def clean(self):\n for i in range(len(self.asteroid_type) - 1, -1, -1):\n x, y = self.get_coords(self.asteroid_type[i])\n if x < -self.gap:\n self.del_asteroid(i)","def minimalTextCleaning(row, field):\n\n # force encoding\n encoded_text = row[field].encode(encoding = 'ascii',errors = 'replace')\n decoded_text = encoded_text.decode(encoding='ascii',errors='strict')\n remove_funky_chars = str(decoded_text).replace(\"?\", \" \")\n lower_case = str(remove_funky_chars).lower().strip()\n\n # strip redundant whitespace\n cleaned_text = re.sub(' +', ' ', lower_case)\n\n\n # strip signature lines\n cleaned_text = cleaned_text.replace(\"_\", \"\")\n\n return cleaned_text","def clean_inp(self):\n self.E_str = \"clean_inp\"\n\n # First remove any comment lines\n new_ltxt = []\n for line_num, line in enumerate(self.file_ltxt):\n edit_line, comment = gen_parse.rm_comment_from_line(line)\n edit_line = edit_line.rstrip()\n if edit_line:\n new_ltxt.append(edit_line)\n self.file_ltxt = new_ltxt[:]\n\n # Get line nums for error messages -before the inp cleaning\n self.line_nums = list(range(1, len(self.file_ltxt)+1))\n for line_num in self.line_nums:\n self.file_ltxt_orig[line_num] = self.file_ltxt[line_num - 1]\n self.line_num = 0\n\n self.clean_open_close_brace()","def test_04_remove_annotations(self):\n self.addAnnotation(\"annotation1\", self.host.id, \"HOST\")\n self.removeAnnotation(self.added_annotations[-1].annotation.id)\n del self.added_annotations[-1]","def _purify(self, line_str):\n string = line_str.strip('\\n')\n string = string.strip()\n comment_idx = string.find('//')\n if comment_idx == -1:\n return string.strip()\n elif comment_idx == 0:\n return None\n else:\n return string[0:comment_idx].strip()","def clean_data(self, path, exclude_msgtypes=None):","def clean_me(args):\n with open(args.input, 'rb') as infile:\n with open(args.output, 'wb') as outfile:\n \n for line in infile:\n if not 'xsi:nil=\"true\"' in line:\n outfile.write(line)\n else:\n print \"Removing %s\" % line","def strip_rule(line):\n\n return \" \".join(line.split())","def clean_record(text, \n page_breaks=True,\n midline_returns=True,\n time_marks=True):\n clean_text = text\n if(page_breaks):\n clean_text = remove_page_breaks(clean_text)\n if(midline_returns):\n clean_text = remove_midline_returns(clean_text)\n if(time_marks):\n clean_text = remove_time_marks(clean_text)\n \n return clean_text","def process_body(line):\n fields = line.split('\\t') # preserves newline\n infos = fields[7].split(';')\n\n whitelisted = [\n info for info in infos\n if any(\n info.startswith(x + '=') or info == x\n for x in WHITELISTED_ANNOTATIONS\n )\n ]\n\n fields[7] = ';'.join(whitelisted)\n return '\\t'.join(fields)","def remove_some_extraneous_information(variant):\n for key in ['xpos','xstop','vep_annotations',]: variant.pop(key, None)","def clean(dataset_path: str) -> str:\n def _remove_unused(text: str):\n clean_data = text.lower().strip()\n clean_data = re.sub(\n r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',\n \" \", clean_data)\n clean_data = re.sub(r\"<.*>\", \"\", clean_data)\n clean_data = re.sub(r\"@[a-zA-Z0-9_]+\", \"\", clean_data)\n clean_data = clean_data.replace(\"\\n\", \"\")\\\n .replace(\"#\", \"\")\n return clean_data\n\n dtypes = {\n \"id\": int,\n \"keyword\": str,\n \"location\": str,\n \"text\": str\n }\n\n if \"train\" in dataset_path:\n dtypes[\"target\"] = int\n\n new_path = _make_new_filepath(dataset_path, \"clean\")\n df = pd.read_csv(f\"/data/{dataset_path}\", index_col=\"id\", dtype=dtypes)\n df[\"text\"] = df[\"text\"].apply(_remove_unused)\n df.to_csv(f\"/data/{new_path}\")\n return new_path","def do_clear(self, line):\n self.calc.clear()\n self._debug_stack()","def sanitize(self, line):\n self.line_count = self.line_count + 1\n components = line.split(\",\")\n for comp in components:\n # if any field has IP in it, see if the value matches something in the dict\n items = comp.split(\"=\")\n if \"ip\" in items[0]:\n if items[1] in self._insts:\n # found this dirty IP in our learned dictionary, replace it\n dirty_ip = items[1]\n clean_ip = self._insts[dirty_ip]\n line = re.sub(dirty_ip, clean_ip, line, 1)\n\n # if this message has a pdu, clean up the pdu too\n msg_type = self._extract_by_key(line, \"type\")\n if \"sflow\" in msg_type or \"event\" in msg_type:\n pdu = self._extract_by_key(line, \"pdu\")\n # substitute the converted IP based on type\n if \".\" in dirty_ip:\n # v4\n line = re.sub(self._v4_string_to_hex(dirty_ip),\n self._v4_string_to_hex(clean_ip), line)\n\n pdu = self.fix_checksum(pdu)\n\n line = line[0: (line.find(\"pdu=\")) +4] + pdu + \",\\n\"\n else:\n # v6 - remove : and go to lower case before swap\n dirty_swap = re.sub(\":\", \"\", dirty_ip)\n dirty_swap = dirty_swap.lower()\n line = re.sub(dirty_swap, self._v4_string_to_hex(clean_ip), line)\n if (args.hexdump):\n pdu_hex = pdu\n pdu_hex = \" \".join(pdu_hex[i:i+2] for i in range(0, len(pdu_hex), 2)) #put timestamp and offset in front of pdu hex\n pdu_hex = pdu[0:15] + \" 000000 \" + pdu_hex + \" ,\\n\"\n hexdump_file.write(pdu_hex)\n return line","def process(self,line):\n\n pattern = re.compile(\"@.*?@\")\n matches = pattern.findall(line)\n for m in matches:\n replacement = r\"<small>{}</small>\".format(re.escape(m[1:-1]))\n line = pattern.sub(replacement,line)\n\n return line","def trim_data(data, attributes):\n return data.drop(attributes, axis=1)","def clear_annotation(self):\n\n self.xValues = []\n self.yValues = []\n self.colors = []\n\n self.stop_video()","def clean_data(td):\n data = td.string\n try:\n return data.strip(\" \\n:-\")\n except AttributeError:\n return u\"\"","def remove_empty_lines(self):\n self.result_code = open(\"result.c\", \"r\") # Opening the intermediate file in 'read' mode.\n self.line_array = self.result_code.readlines() # Obtaining an array of strings, where each string is a line from the intermediate file.\n self.result_code.close() # Closing the intermediate file.\n self.result_code = open(\"result.c\",\"w\") #Opening the intermediate file in 'write' mode.\n # Looping over all the lines in the input file.\n for line in self.line_array:\n # Checking if the line is empty.\n if line != \"\\n\":\n self.result_code.write(line) # Writing the non-empty line onto the intermediate file.\n self.result_code.close() # Closing the intermediate file.","def filter_line(self, line):\n if line.startswith(\"<\"):\n # Simply filter out all lines beginning with '<', which are metadata\n return None\n\n # Some metadata-like text is also included at the start of lines, followed by \". - \"\n if u\". - \" in line:\n __, __, line = line.partition(u\". - \")\n\n # Remove -s and spaces from the start of lines\n # Not sure why they're often there, but it's just how the transcripts were formatted\n line = line.lstrip(u\"- \")\n\n # Skip lines that are fully surrounded by brackets: they're typically descriptions of what happened\n # E.g. (Applause)\n if line.startswith(u\"(\") and line.endswith(u\")\"):\n return None\n\n # It's common for a speaker's first utterance to start with a marker indicating the original language\n line = language_indicator_re.sub(u\"\", line)\n return line","def remove_ats(self):\n\t\tfor key in self.keys():\n\t\t\tif key[:1] == '@':\n\t\t\t\ttry: del self[key]\n\t\t\t\texcept: pass","def _chop_end_codes(line):\n return re.sub(r\"\\s\\s\\s\\s+[\\w]{4}.\\s+\\d*\\Z\", \"\", line)","def _clean_commit(self, line):\n cleaned_line = {\n 'repo': line['origin'],\n 'hash': line['data_commit'],\n 'author': line['data_Author'],\n 'category': \"commit\",\n 'created_date': utils.str_to_dt_data(line['data_AuthorDate']),\n 'commit': line['data_Commit'],\n 'commit_date': utils.str_to_dt_data(line['data_CommitDate']),\n 'files_no': len(line['data_files']),\n 'refs': line['data_refs'],\n 'parents': line['data_parents'],\n 'files': line['data_files']\n }\n\n actions = 0\n for file in line['data_files']:\n if 'action' in file:\n actions += 1\n cleaned_line['files_action'] = actions\n\n try:\n non_merge = math.isnan(line['data_Merge'])\n\n except (TypeError, KeyError):\n non_merge = False\n\n cleaned_line['merge'] = not non_merge\n return cleaned_line","def clean(self):\n # Perform the standard ACE cleaning\n max_status = mm_ace.clean(self)\n\n # Replace bad values with NaN and remove times with no valid data\n self.data = self.data[self.data['status'] <= max_status]\n\n return","def clean_json(self, line_no, row):\n if len(row) not in [4, 5]:\n return False\n return True","def clean_line_generator_v2(df_pkl=None, fn='untitled'):","def clear(self):\n self.clear_markers()\n self.l_marker.remove()\n self.l_line.remove()\n self.r_marker.remove()\n self.r_line.remove()","def clean_data(self, lines):\n\n data = []\n curr = None\n for line in lines:\n line = self.clean_line(line)\n\n temp = []\n quotes = 0\n for item in line.split():\n if quotes % 2 == 0:\n temp.append(item)\n else:\n temp[-1] += item\n quotes += item.count(\"\\\"\")\n line = temp\n\n if not line:\n continue\n if curr:\n if self.compare_keys(curr, line):\n curr = self.merge_lines(curr, line)\n else:\n data.append(self.add_line(curr))\n curr = line\n else:\n curr = line\n if curr:\n data.append(self.add_line(curr))\n return data","def _chop_end_misc(line):\n return re.sub(r\"\\s+\\d\\d-\\w\\w\\w-\\d\\d\\s+[1-9][0-9A-Z]{3}\\s*\\Z\", \"\", line)","def clean_serial_data(data):\n clean_data = []\n line_data = []\n for line in data:\n print (line)\n #line = float(line)\n clean_data.append(int(line)/1000)\n \n return clean_data","def remove_line(self, origin):\n current_tile = self.board[origin[0]][origin[1]]\n\n if current_tile.is_dot:\n temp = current_tile.next\n current_tile.next = None\n current_tile = temp\n\n # Remove color of all non dot tiles in line.\n while current_tile and current_tile.color and not current_tile.is_dot:\n temp = current_tile.next\n current_tile.color = None\n current_tile.next = None\n current_tile = temp","def clean(self):\n # Perform the standard ACE cleaning\n max_status = mm_ace.clean(self)\n\n # Replace bad values with NaN and remove times with no valid data\n ecols = ['eflux_38-53', 'eflux_175-315']\n\n # Evaluate the electron flux data\n self[self.data['status_e'] > max_status, ecols] = np.nan\n\n # Evaluate the proton flux data\n pcols = ['pflux_47-68', 'pflux_115-195', 'pflux_310-580',\n 'pflux_795-1193', 'pflux_1060-1900']\n self[self.data['status_p'] > max_status, pcols] = np.nan\n\n # Include both fluxes and the anisotropy index in the removal eval\n eval_cols = ecols + pcols\n eval_cols.append('anis_ind')\n\n # Remove lines without any good data\n good_cols = (np.isfinite(self.data.loc[:, eval_cols])).sum(axis=1)\n bad_index = good_cols[good_cols == 0].index\n self.data = self.data.drop(index=bad_index)\n\n return","def test_line_strip():\n for _x in range(100):\n l_str = \" \".join([random_str(5, 10) for x in range(30)])\n l_str = (\" \" * randint(0, 10)) + l_str + (\" \" * randint(0, 10))\n line = Line(l_str, random_str(10, 20), randint(1, 10000))\n # Strip the string\n l_stripped = line.strip()\n assert l_stripped == l_str.strip()\n assert isinstance(l_stripped, Line)\n assert l_stripped.file == line.file\n assert l_stripped.number == line.number","def cleanData(rawData):\n\trawData = re.sub(r'R-LRB- \\(', r'R-LRB- -LRB-', rawData)\n\trawData = re.sub(r'R-RRB- \\)', r'R-RRB- -RRB-', rawData)\n\trawData = re.sub(r'R-RRB- \\(', r'R-RRB- -LRB-', rawData)\n\trawData = re.sub(r'-LRB- \\(', r'-LRB- -LRB-', rawData)\n\trawData = re.sub(r'-RRB- \\)', r'-RRB- -RRB-', rawData)\n\trawData = re.sub(r'PU \\(', r'PU -LRB-', rawData)\n\trawData = re.sub(r'PU \\)', r'PU -RRB-', rawData)\n\trawData = re.sub(r':-\\)', r'smileyface', rawData)\n\n\treturn rawData","def CleanLineEndings(aLine):\n str = aLine.replace(cr, \"\") # remove cr\n str = str.replace(lf, \"\") # remove lf\n return str","def clean_lines(df_column):\n \n clean_lines = []\n # pattern for html tags\n tag_match = re.compile('<.*?>')\n # patterm for website\n website_match = re.compile('https?:\\/\\/.*[\\r\\n]*')\n # pattern for tex\n tex_match = re.compile('\\$\\$?.+?\\$\\$?')\n \n for line in df_column:\n s = re.sub(tag_match, '', line)\n s = re.sub(website_match, '[website]', s)\n s = re.sub(tex_match, '[tex]', s)\n # replace extra whitespace with spaces\n for x in string.whitespace:\n s = s.replace(x, ' ')\n clean_lines.append(s)\n \n return clean_lines","def clean(df):","def cleanup(segment):\n cnt = ''.join(segment.file_content)\n index = cnt.find('\\\\annotate')\n if index < 0:\n return\n while index >= 0:\n cnt, new_ind = parse_annotation(cnt, index)\n index = cnt.find('\\\\annotate', new_ind)\n f = codecs.open(segment.filename, 'w', 'utf-8')\n f.write(cnt)\n f.close()\n info('Updated: {} {}'.format(segment.voice_name, segment.name))","def clear(self) -> None:\n self.raw = ''\n self.extent = None # type: ignore[assignment]\n self._lines = []\n self.items = None\n self.seen_headers = {}\n return","def clean_smile(self, smi):\n smi = smi.replace('\\n', '')\n return smi","def clean_rows(reader):\n return [[a.strip() for a in row] for row in reader if row]","def clean_comments(self):\n new_lines = list()\n for line in self.lines:\n if ((not line.startswith(\"//\")) & (not line.isspace()) &\n (not line.startswith(\"/*\") & (not line.startswith(\"*/\")))):\n line = Parser.strip_line(line)\n new_lines.append(line)\n self.lines = new_lines","def pruneMarks(self):\n self.__prune_marks(self.nodes(data=True))","def clean(line):\n line = line.strip('\\n').strip()\n line = line.replace('\\xe2\\x80\\x93', '-')\n line = line.replace('\\xe2\\x80\\x99', '\\'')\n\n return line","def _rstrip(line, JUNK='\\n \\t'):\r\n\r\n i = len(line)\r\n while i > 0 and line[i-1] in JUNK:\r\n i -= 1\r\n return line[:i]","def clean_textual_attributes(self):\n for attribute in self.__textual_attributes:\n for index, text in self.__df[attribute].dropna().iteritems():\n text = remove_non_printable_characters(text)\n text = remove_html_tags(text)\n text = remove_unnecessary_spaces(text)\n self.__df.at[index, attribute] = text","def experience_clean_row(row_of_data):\n experience = row_of_data.get('experience')\n z = list(set(remove_filler_words(experience)))\n return z","def drop_little_line(data, seuil):\n idx = []\n\n for i, line in enumerate(data.abstract):\n if len(line.split()) < seuil:\n idx.append(i)\n data.drop(data.index[idx])\n data.index = range(len(data.index))\n return data","def minimal_clean_data_inplace(df):\n # There are some 'unknown' users in train dataset only\n unknown_data_lines = df['sexo'].isnull() & df['age'].isnull() & df['ind_empleado'].isnull() & \\\n df['fecha_alta'].isnull() & df['pais_residencia'].isnull()\n\n logging.info(\"- Number of lines with unknown data : %s\" % unknown_data_lines.sum())\n\n # Remove these users as clients\n _clients = df[unknown_data_lines]['ncodpers'].unique()\n bad_lines = df['ncodpers'].isin(_clients)\n df.drop(df[bad_lines].index, inplace=True)\n\n logging.info(\"- Number of columns with nan : %s\" % df.isnull().any().sum())\n\n # Remove accent\n df.loc[df['nomprov'] == \"CORU\\xc3\\x91A, A\", \"nomprov\"] = \"CORUNA\"\n\n unknown_cols = ['sexo',\n 'ind_empleado',\n 'pais_residencia',\n 'ult_fec_cli_1t',\n 'conyuemp',\n 'canal_entrada',\n 'nomprov',\n 'segmento',\n 'tiprel_1mes',\n 'indrel_1mes']\n # Start with cols -> replace nan with UNKNOWN\n for col in unknown_cols:\n df.loc[df[col].isnull(), col] = \"UNKNOWN\"\n\n # Set unknown renta to -99\n df.loc[df['renta'].isnull(), 'renta'] = -99\n\n # Next `fecha_alta` :\n assert df['fecha_alta'].isnull().sum() == 0, \\\n \"Need to replace nan in 'fecha_alta', count=%s\" % df['fecha_alta'].isnull().sum()\n\n # **Remove 'tipodom' and 'cod_prov' columns**\n df.drop([\"tipodom\", \"cod_prov\"], axis=1, inplace=True)\n \n # Convert 'ind_nuevo' to int\n df['ind_nuevo'] = df['ind_nuevo'].astype(int)\n \n # Remove floating point at string indrel_1mes\n df['indrel_1mes'] = df['indrel_1mes'].apply(lambda x: str(int(float(x))) if len(x) == 3 else x)\n\n if \"ind_nomina_ult1\" in df.columns and \"ind_nom_pens_ult1\" in df.columns:\n # Target labels : `ind_nomina_ult1`, `ind_nom_pens_ult1` : nan -> 0\n # I could try to fill in missing values for products by looking at previous months,\n # but since it's such a small number of values for now I'll take the cheap way out.\n df.loc[df.ind_nomina_ult1.isnull(), \"ind_nomina_ult1\"] = 0\n df.loc[df.ind_nom_pens_ult1.isnull(), \"ind_nom_pens_ult1\"] = 0\n\n # replace 'antiguedad' with the number of months between 'fecha_alta' and 'fecha_dato'\n func1 = lambda x: _to_ym_dec(to_yearmonth(x))\n func2 = lambda x: max(_to_nb_months(x), 0) \n\n v1 = df['fecha_dato'].apply(func1)\n v2 = df['fecha_alta'].apply(func1)\n v3 = (v1 - v2).apply(func2)\n df.loc[:, 'antiguedad'] = v3\n \n # Replace 'ult_fec_cli_1t' by current nb of months from fecha_dato, if negative, set to zero\n mask = df['ult_fec_cli_1t'] == 'UNKNOWN'\n df.loc[mask, 'ult_fec_cli_1t'] = df[mask]['fecha_dato']\n v1 = df['fecha_dato'].apply(func1)\n v2 = df['ult_fec_cli_1t'].apply(func1)\n v3 = (v1 - v2).apply(func2)\n df.loc[:, 'ult_fec_cli_1t'] = v3","def remove_line(self, id):\n id = id_force_tuple(id)\n prf = self.prf.get_parent_proof(id)\n split = id[-1]\n prf.items = prf.items[:split] + prf.items[split+1:]\n for item in prf.items[split:]:\n decr_proof_item(item, id)\n\n self.check_proof(compute_only=True)","def cleanGpt2Prediction(input_text, prediction):\n if input_text and input_text[-1] != \" \": input_text += \" \"\n prediction = input_text + prediction.strip()\n cutted = \"\"\n if prediction[-1] != '.':\n last_dot_idx = prediction.rfind('. ')\n if last_dot_idx != -1:\n cutted = prediction[last_dot_idx + 1:]\n prediction = prediction[:last_dot_idx + 1]\n print(f\"\"\"{'='*20}\\n-> Removed:\\n|{cutted}|\\nat the end of prediction\"\"\")\n res = [line for line in prediction.split('\\n') if line and line.strip()[0] != '\"']\n return '\\n'.join(res)","def _(event):\n deleted = line.delete_before_cursor(count=-line.document.get_start_of_line_position())\n line.set_clipboard(ClipboardData(deleted))","def strip_line_ending( line ):\n\n # surely there's a better way?\n while len(line) and line[-1] in '\\n\\r':\n line = line[:-1]\n\n while len(line) and line[0] in '\\n\\r':\n line = line[1:]\n \n return line","def strip(self):\n self.document_type = self.document_type.strip()\n self.document_reg_id = self.document_reg_id.strip()\n self.owner_cross_reference = self.owner_cross_reference.strip()\n self.routing_slip_number = self.routing_slip_number.strip()\n self.bcol_account = self.bcol_account.strip()\n self.dat_number = self.dat_number.strip()\n self.examiner_id = self.examiner_id.strip()\n self.update_id = self.update_id.strip()\n self.phone_number = self.phone_number.strip()\n self.attention_reference = self.attention_reference.strip()\n self.name = self.name.strip()\n self.legacy_address = self.legacy_address.strip()\n self.consideration_value = self.consideration_value.strip()\n self.affirm_by_name = self.affirm_by_name.strip()\n self.liens_with_consent = self.liens_with_consent.strip()\n self.client_reference_id = self.client_reference_id.strip()\n self.own_land = self.own_land.strip()","def remove_line(self, hash_code):\n line_index = None\n marker_index = None\n\n for i, lines in enumerate(self._lines):\n for j, line in enumerate(lines):\n if hash_graphics_line(line) == hash_code:\n marker_index = j\n line_index = i\n\n if line_index is None or marker_index is None:\n return None\n\n del self._lines[line_index][marker_index]\n self.set_changed()\n\n if len(self._lines[line_index]) == 0:\n del self._lines[line_index]\n return None\n\n return self._lines[line_index]","def clean_data(data):\n src_list = []\n no_net_view = []\n for row in range(data.nrows):\n # Ignore header row.\n if row == 0:\n continue\n # Ignore blank row.\n if data.row_values(row)[1] == '' and \\\n data.row_values(row)[15] == '':\n continue\n # Capture lines that do not have a view listed.\n if data.row_values(row)[1] and not data.row_values(row)[15]:\n no_net_view.append(data.row_values(row))\n continue\n src_list.append(data.row_values(row))\n\n # Clean's src_list values.\n src_list = [[item.replace('\\t', '') for item in row\n if isinstance(item, str)]\n for row in src_list]\n src_list = [[item.replace('\\n', ', ') for item in row\n if isinstance(item, str)]\n for row in src_list]\n src_list = [[item.replace(', ,', ', ') for item in row\n if isinstance(item, str)]\n for row in src_list]\n src_list = [[item.strip() for item in row\n if isinstance(item, str)]\n for row in src_list]\n for enum, row in enumerate(src_list):\n row[0] = row[0].lower()\n src_list[enum] = row\n return src_list","def remove(self, from_line, from_col, to_line, to_col):\n assert from_line == to_line\n from_col = self.canonicalize_column_index(from_line, from_col)\n to_col = self.canonicalize_column_index(to_line, to_col)\n\n col_off = self.col_offs[from_line]\n adj_from_col = col_off.get_rewritten_pos(from_col)\n adj_to_col = col_off.get_rewritten_pos(to_col)\n theline = self.lines[from_line]\n self.lines[from_line] = theline[:adj_from_col] + theline[adj_to_col:]\n col_off.remove(from_col, to_col-from_col)","def _clean_data(self):\n if not path.exists('auto-mpg.data.txt'):\n logger.info('Could not find auto-mpg.data.txt in the current working directory')\n sys.exit()\n else:\n try:\n with open('auto-mpg.data.txt', 'r') as dirty_data:\n with open('auto-mpg.clean.txt', 'w') as clean_data:\n ## counter for row writes\n counter = 0\n for row in csv.reader(dirty_data):\n clean_data.write(row[0].expandtabs(1) + '\\n')\n counter +=1\n except Exception as e:\n logger.info('File error occurred: {e}. Exiting')\n sys.exit()","def _strip_lines(lines):\n for line in lines:\n stripped = line.strip()\n if stripped:\n yield stripped","def reset_annotations(self):\n # FIXME: this state does not make sense\n self.annotation_date_set = False\n self.annotation_comment_set = False\n self.annotation_type_set = False\n self.annotation_spdx_id_set = False","def unlines(line):\n\n return line.translate(str.maketrans('\\n', ' '))","def cleaned_contents(self):\n snip_with_code = re.compile(\"(//.*snip(\\-file)*:?.*\\n)(\\+\\n)?(\\[.*\\]\\n)*----\\n(.*\\n)*?----\\n\", flags=re.IGNORECASE)\n cleaned = re.sub(snip_with_code, r'\\1', self.contents)\n return cleaned","def clean_data(self):\n data_clean = []\n for item in self.data:\n if int(item[2]) >= self.seq_length and int(item[2]) <= self.max_frames:# and item[1] in self.classes:\n data_clean.append(item)\n\n return data_clean","def clean(args):\n with_dataset(args, Dataset._clean)","def education_clean_row(row_of_data):\n education = row_of_data.get('education')\n z = list(set(remove_filler_words(education)))\n return z","def _strip_once(value):\n s = MLStripper()\n s.feed(value)\n s.close()\n return s.get_data()","def applyMorphologicalCleaning(self, image):","def remove_comments(line):\n hashPos = line.find('#')\n return line[:hashPos] if hashPos >= 0 else line","def clean(datapath):\n red_flags = ['â€', 'Â']\n\n with open(datapath, 'r') as file:\n data = json.load(file)\n\n bad = []\n good = []\n for article in progress(data, 'Fixing {0} articles...'.format(len(data))):\n for key in ['title', 'text']:\n article[key] = fix_text_segment(article[key])\n\n flagged = False\n for flag in red_flags:\n if flag in article['text'] + article['title']:\n bad.append(article)\n flagged = True\n break\n if not flagged:\n good.append(article)\n\n print('Getting rid of {0} bad articles.'.format(len(bad)))\n\n outpath = datapath.replace('.json', '_cleaned.json')\n with open(outpath, 'w') as file:\n json.dump(good, file)","def strip_comments(line):\n if \"#\" in line:\n return line[:line.find(\"#\")]\n else:\n return line"],"string":"[\n \"def cleaning (data):\",\n \"def clean_line(self, line):\\n\\n if \\\"#\\\" in line:\\n temp = line.split(\\\"#\\\")\\n if len(temp) < 2:\\n return \\\"\\\"\\n else:\\n temp = temp[0] + \\\"\\\\n\\\"\\n\\n # make sure the \\\"#\\\" isn't in quotes\\n if temp.count(\\\"\\\\\\\"\\\") % 2 == 0:\\n line = temp\\n\\n line = line.replace(\\\"}\\\", \\\" } \\\").replace(\\\"{\\\", \\\" { \\\")\\n while \\\"=\\\" in line:\\n line = self.replace_equals(line)\\n line = line.lstrip()\\n return line\",\n \"def remove_code_annotations(line_to_transform):\\n line_to_transform = str(line_to_transform)\\n line_to_transform = line_to_transform.split(' #', 1)[0]\\n line_to_transform = line_to_transform.replace(':', '')\\n line_to_transform = line_to_transform.replace('\\\\t', '')\\n line_to_transform = line_to_transform.replace(' ', '')\\n line_to_transform = line_to_transform.replace('\\\\n', '')\\n line_to_transform = line_to_transform.replace('elif ', '')\\n line_to_transform = line_to_transform.replace('if ', '')\\n line_to_transform = line_to_transform.replace('else ', '')\\n line_to_transform = line_to_transform.replace('else', '')\\n line_to_transform = line_to_transform.replace('def ', '')\\n line_to_transform = line_to_transform.replace('for ', '')\\n line_to_transform = line_to_transform.replace('while ', '')\\n return line_to_transform\",\n \"def __clean_line_comments(self):\\n self.lines = [l for l in self.lines if not l.startswith(\\\"//\\\") and len(l) != 0]\",\n \"def __clean_line_comments(self):\\n self.lines = [l for l in self.lines if not l.startswith(\\\"//\\\") and len(l) != 0]\",\n \"def clean_data(self):\\n for line in self.file:\\n if line.startswith('//') or line.isspace():\\n continue\\n if '//' in line:\\n line = line.split('//')[0]\\n line = line.replace('\\\\n', '')\\n line = line.replace(' ','')\\n self.commands.append(line)\",\n \"def cut_line(self):\\r\\n self.parachute.pop(0)\",\n \"def setCleanAnnotations(self, value):\\n return self._set(cleanAnnotations=value)\",\n \"def mapper_data_cleaning(self, l, line):\\n lineitems = line.split(\\\",\\\")\\n yield (lineitems[0], lineitems[2])\",\n \"def clean(c):\",\n \"def delTcline(self, line):\\n self._checkfigure()\\n ld = self._get_linedict(line)\\n for vline in ld['vlines']:\\n vline.remove()\\n ld['vlines'] = []\",\n \"def strip_line(line):\\n line = line.strip()\\n line = line.rstrip('\\\\n')\\n line = line.rstrip('\\\\t')\\n line = (line.split(\\\"//\\\"))[0]\\n return line\",\n \"def FilterLine(self, a_line):\\n return a_line\",\n \"def strip_warnings(self, line):\\n if line[0] == \\\"|\\\":\\n return \\\"\\\"\\n else:\\n return line\",\n \"def delete_line(self, line):\\n self._checkfigure()\\n ld = self._get_linedict(line)\\n self.delTcline(ld)\\n line = ld['line']\\n line.remove()\\n self.lines.remove(ld)\",\n \"def test__clean_line():\\n LINES = {\\n \\\"One morn before me were three figures seen,\\\":\\n \\\"One morn before me were three figures seen,\\\",\\n \\\"And once—more came they by:-alas! wherefore?\\\":\\n \\\"And once more came they by: alas! wherefore?\\\",\\n }\\n for line, clean_line in LINES.items():\\n assert(LineBuilder(line)._clean_line() == clean_line)\",\n \"def clean(self, line):\\r\\n m = self.RE.match(line)\\r\\n if line.strip() == \\\">\\\":\\r\\n return \\\"\\\"\\r\\n elif m:\\r\\n return m.group(2)\\r\\n else:\\r\\n return line\",\n \"def remove_lines():\\n work_folder = os.path.join(CURRENT_FOLDER, \\\"..\\\\\\\\Data\\\\\\\\weather_data\\\")\\n with open(os.path.join(work_folder, \\\"filtered_merged_history_KMDW.csv\\\"), \\\"w\\\") as outfile:\\n with open(os.path.join(work_folder, \\\"merged_history_KMDW.csv\\\")) as infile:\\n outfile.write(infile.next())\\n for line in infile:\\n if line[0].isdigit():\\n outfile.write(line)\",\n \"def clean(self, line):\\n m = self.RE.match(line)\\n if line.strip() == \\\">\\\":\\n return \\\"\\\"\\n elif m:\\n return m.group(2)\\n else:\\n return line\",\n \"def rstrip_line(line):\\n return line.rstrip()\",\n \"def clean_chunk(chunk):\\n return '\\\\n'.join([x[1:] for x in chunk.split('\\\\n')\\n if x and x[0] not in ('-', '@')])\",\n \"def clean(line):\\n line = line.lower().replace(\\\"\\\\n\\\",\\\" \\\").replace(\\\"\\\\r\\\",\\\"\\\").replace(',',\\\"\\\").replace(\\\">\\\",\\\"> \\\").replace(\\\"<\\\", \\\" <\\\").replace(\\\"|\\\",\\\" \\\")\\n return line\",\n \"def process(lines):\\n lines = list(map(_clean, lines))\\n # lines = list(map(_split, lines))\\n return lines\",\n \"def removeAnnotation(self,i=0):\\n #print \\\"REMOVE %s\\\" % i\\n map(undraw,self._annotations[i])\\n del self._annotations[i]\",\n \"def RemoveMarker(self, marker, line):\\n assert isinstance(marker, ed_marker.Marker)\\n marker.Set(self, line, delete=True)\",\n \"def unhighlight_line(self, line):\\n self._checkfigure()\\n ld = self._get_linedict(line)\\n ld['highlighted'] = False\\n self.update_lines()\",\n \"def clean(text):\\n lines = text.split('\\\\n')\\n\\n indx = range(len(lines))\\n indx.reverse()\\n for i in indx:\\n temp = lines[i].strip()\\n if temp == '' or temp.startswith('#'):\\n del lines[i]\\n else:\\n lines[i] = temp\\n\\n return lines\",\n \"def _clean_data(self, dataset):\\n dataset.dropna(inplace=True)\\n # Problem: handle missing data (in a different way), noisy data, inconsistent data\",\n \"def list_strip(line: list):\\n new_line = [field.strip() for field in line]\\n if new_line != line:\\n tpl = \\\"Removed trailing whitespaces in fields of line: {}\\\"\\n msg = tpl.format(line)\\n warnings.warn(msg, ParseIsatabWarning)\\n return new_line\",\n \"def clean_lines(lines):\\n _lines = []\\n for l in lines:\\n l = l.strip().rstrip()\\n if len(l) > 0:\\n _lines.append(l)\\n return _lines\",\n \"def clean(self):\\n for i in range(len(self.asteroid_type) - 1, -1, -1):\\n x, y = self.get_coords(self.asteroid_type[i])\\n if x < -self.gap:\\n self.del_asteroid(i)\",\n \"def minimalTextCleaning(row, field):\\n\\n # force encoding\\n encoded_text = row[field].encode(encoding = 'ascii',errors = 'replace')\\n decoded_text = encoded_text.decode(encoding='ascii',errors='strict')\\n remove_funky_chars = str(decoded_text).replace(\\\"?\\\", \\\" \\\")\\n lower_case = str(remove_funky_chars).lower().strip()\\n\\n # strip redundant whitespace\\n cleaned_text = re.sub(' +', ' ', lower_case)\\n\\n\\n # strip signature lines\\n cleaned_text = cleaned_text.replace(\\\"_\\\", \\\"\\\")\\n\\n return cleaned_text\",\n \"def clean_inp(self):\\n self.E_str = \\\"clean_inp\\\"\\n\\n # First remove any comment lines\\n new_ltxt = []\\n for line_num, line in enumerate(self.file_ltxt):\\n edit_line, comment = gen_parse.rm_comment_from_line(line)\\n edit_line = edit_line.rstrip()\\n if edit_line:\\n new_ltxt.append(edit_line)\\n self.file_ltxt = new_ltxt[:]\\n\\n # Get line nums for error messages -before the inp cleaning\\n self.line_nums = list(range(1, len(self.file_ltxt)+1))\\n for line_num in self.line_nums:\\n self.file_ltxt_orig[line_num] = self.file_ltxt[line_num - 1]\\n self.line_num = 0\\n\\n self.clean_open_close_brace()\",\n \"def test_04_remove_annotations(self):\\n self.addAnnotation(\\\"annotation1\\\", self.host.id, \\\"HOST\\\")\\n self.removeAnnotation(self.added_annotations[-1].annotation.id)\\n del self.added_annotations[-1]\",\n \"def _purify(self, line_str):\\n string = line_str.strip('\\\\n')\\n string = string.strip()\\n comment_idx = string.find('//')\\n if comment_idx == -1:\\n return string.strip()\\n elif comment_idx == 0:\\n return None\\n else:\\n return string[0:comment_idx].strip()\",\n \"def clean_data(self, path, exclude_msgtypes=None):\",\n \"def clean_me(args):\\n with open(args.input, 'rb') as infile:\\n with open(args.output, 'wb') as outfile:\\n \\n for line in infile:\\n if not 'xsi:nil=\\\"true\\\"' in line:\\n outfile.write(line)\\n else:\\n print \\\"Removing %s\\\" % line\",\n \"def strip_rule(line):\\n\\n return \\\" \\\".join(line.split())\",\n \"def clean_record(text, \\n page_breaks=True,\\n midline_returns=True,\\n time_marks=True):\\n clean_text = text\\n if(page_breaks):\\n clean_text = remove_page_breaks(clean_text)\\n if(midline_returns):\\n clean_text = remove_midline_returns(clean_text)\\n if(time_marks):\\n clean_text = remove_time_marks(clean_text)\\n \\n return clean_text\",\n \"def process_body(line):\\n fields = line.split('\\\\t') # preserves newline\\n infos = fields[7].split(';')\\n\\n whitelisted = [\\n info for info in infos\\n if any(\\n info.startswith(x + '=') or info == x\\n for x in WHITELISTED_ANNOTATIONS\\n )\\n ]\\n\\n fields[7] = ';'.join(whitelisted)\\n return '\\\\t'.join(fields)\",\n \"def remove_some_extraneous_information(variant):\\n for key in ['xpos','xstop','vep_annotations',]: variant.pop(key, None)\",\n \"def clean(dataset_path: str) -> str:\\n def _remove_unused(text: str):\\n clean_data = text.lower().strip()\\n clean_data = re.sub(\\n r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\\\(\\\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',\\n \\\" \\\", clean_data)\\n clean_data = re.sub(r\\\"<.*>\\\", \\\"\\\", clean_data)\\n clean_data = re.sub(r\\\"@[a-zA-Z0-9_]+\\\", \\\"\\\", clean_data)\\n clean_data = clean_data.replace(\\\"\\\\n\\\", \\\"\\\")\\\\\\n .replace(\\\"#\\\", \\\"\\\")\\n return clean_data\\n\\n dtypes = {\\n \\\"id\\\": int,\\n \\\"keyword\\\": str,\\n \\\"location\\\": str,\\n \\\"text\\\": str\\n }\\n\\n if \\\"train\\\" in dataset_path:\\n dtypes[\\\"target\\\"] = int\\n\\n new_path = _make_new_filepath(dataset_path, \\\"clean\\\")\\n df = pd.read_csv(f\\\"/data/{dataset_path}\\\", index_col=\\\"id\\\", dtype=dtypes)\\n df[\\\"text\\\"] = df[\\\"text\\\"].apply(_remove_unused)\\n df.to_csv(f\\\"/data/{new_path}\\\")\\n return new_path\",\n \"def do_clear(self, line):\\n self.calc.clear()\\n self._debug_stack()\",\n \"def sanitize(self, line):\\n self.line_count = self.line_count + 1\\n components = line.split(\\\",\\\")\\n for comp in components:\\n # if any field has IP in it, see if the value matches something in the dict\\n items = comp.split(\\\"=\\\")\\n if \\\"ip\\\" in items[0]:\\n if items[1] in self._insts:\\n # found this dirty IP in our learned dictionary, replace it\\n dirty_ip = items[1]\\n clean_ip = self._insts[dirty_ip]\\n line = re.sub(dirty_ip, clean_ip, line, 1)\\n\\n # if this message has a pdu, clean up the pdu too\\n msg_type = self._extract_by_key(line, \\\"type\\\")\\n if \\\"sflow\\\" in msg_type or \\\"event\\\" in msg_type:\\n pdu = self._extract_by_key(line, \\\"pdu\\\")\\n # substitute the converted IP based on type\\n if \\\".\\\" in dirty_ip:\\n # v4\\n line = re.sub(self._v4_string_to_hex(dirty_ip),\\n self._v4_string_to_hex(clean_ip), line)\\n\\n pdu = self.fix_checksum(pdu)\\n\\n line = line[0: (line.find(\\\"pdu=\\\")) +4] + pdu + \\\",\\\\n\\\"\\n else:\\n # v6 - remove : and go to lower case before swap\\n dirty_swap = re.sub(\\\":\\\", \\\"\\\", dirty_ip)\\n dirty_swap = dirty_swap.lower()\\n line = re.sub(dirty_swap, self._v4_string_to_hex(clean_ip), line)\\n if (args.hexdump):\\n pdu_hex = pdu\\n pdu_hex = \\\" \\\".join(pdu_hex[i:i+2] for i in range(0, len(pdu_hex), 2)) #put timestamp and offset in front of pdu hex\\n pdu_hex = pdu[0:15] + \\\" 000000 \\\" + pdu_hex + \\\" ,\\\\n\\\"\\n hexdump_file.write(pdu_hex)\\n return line\",\n \"def process(self,line):\\n\\n pattern = re.compile(\\\"@.*?@\\\")\\n matches = pattern.findall(line)\\n for m in matches:\\n replacement = r\\\"<small>{}</small>\\\".format(re.escape(m[1:-1]))\\n line = pattern.sub(replacement,line)\\n\\n return line\",\n \"def trim_data(data, attributes):\\n return data.drop(attributes, axis=1)\",\n \"def clear_annotation(self):\\n\\n self.xValues = []\\n self.yValues = []\\n self.colors = []\\n\\n self.stop_video()\",\n \"def clean_data(td):\\n data = td.string\\n try:\\n return data.strip(\\\" \\\\n:-\\\")\\n except AttributeError:\\n return u\\\"\\\"\",\n \"def remove_empty_lines(self):\\n self.result_code = open(\\\"result.c\\\", \\\"r\\\") # Opening the intermediate file in 'read' mode.\\n self.line_array = self.result_code.readlines() # Obtaining an array of strings, where each string is a line from the intermediate file.\\n self.result_code.close() # Closing the intermediate file.\\n self.result_code = open(\\\"result.c\\\",\\\"w\\\") #Opening the intermediate file in 'write' mode.\\n # Looping over all the lines in the input file.\\n for line in self.line_array:\\n # Checking if the line is empty.\\n if line != \\\"\\\\n\\\":\\n self.result_code.write(line) # Writing the non-empty line onto the intermediate file.\\n self.result_code.close() # Closing the intermediate file.\",\n \"def filter_line(self, line):\\n if line.startswith(\\\"<\\\"):\\n # Simply filter out all lines beginning with '<', which are metadata\\n return None\\n\\n # Some metadata-like text is also included at the start of lines, followed by \\\". - \\\"\\n if u\\\". - \\\" in line:\\n __, __, line = line.partition(u\\\". - \\\")\\n\\n # Remove -s and spaces from the start of lines\\n # Not sure why they're often there, but it's just how the transcripts were formatted\\n line = line.lstrip(u\\\"- \\\")\\n\\n # Skip lines that are fully surrounded by brackets: they're typically descriptions of what happened\\n # E.g. (Applause)\\n if line.startswith(u\\\"(\\\") and line.endswith(u\\\")\\\"):\\n return None\\n\\n # It's common for a speaker's first utterance to start with a marker indicating the original language\\n line = language_indicator_re.sub(u\\\"\\\", line)\\n return line\",\n \"def remove_ats(self):\\n\\t\\tfor key in self.keys():\\n\\t\\t\\tif key[:1] == '@':\\n\\t\\t\\t\\ttry: del self[key]\\n\\t\\t\\t\\texcept: pass\",\n \"def _chop_end_codes(line):\\n return re.sub(r\\\"\\\\s\\\\s\\\\s\\\\s+[\\\\w]{4}.\\\\s+\\\\d*\\\\Z\\\", \\\"\\\", line)\",\n \"def _clean_commit(self, line):\\n cleaned_line = {\\n 'repo': line['origin'],\\n 'hash': line['data_commit'],\\n 'author': line['data_Author'],\\n 'category': \\\"commit\\\",\\n 'created_date': utils.str_to_dt_data(line['data_AuthorDate']),\\n 'commit': line['data_Commit'],\\n 'commit_date': utils.str_to_dt_data(line['data_CommitDate']),\\n 'files_no': len(line['data_files']),\\n 'refs': line['data_refs'],\\n 'parents': line['data_parents'],\\n 'files': line['data_files']\\n }\\n\\n actions = 0\\n for file in line['data_files']:\\n if 'action' in file:\\n actions += 1\\n cleaned_line['files_action'] = actions\\n\\n try:\\n non_merge = math.isnan(line['data_Merge'])\\n\\n except (TypeError, KeyError):\\n non_merge = False\\n\\n cleaned_line['merge'] = not non_merge\\n return cleaned_line\",\n \"def clean(self):\\n # Perform the standard ACE cleaning\\n max_status = mm_ace.clean(self)\\n\\n # Replace bad values with NaN and remove times with no valid data\\n self.data = self.data[self.data['status'] <= max_status]\\n\\n return\",\n \"def clean_json(self, line_no, row):\\n if len(row) not in [4, 5]:\\n return False\\n return True\",\n \"def clean_line_generator_v2(df_pkl=None, fn='untitled'):\",\n \"def clear(self):\\n self.clear_markers()\\n self.l_marker.remove()\\n self.l_line.remove()\\n self.r_marker.remove()\\n self.r_line.remove()\",\n \"def clean_data(self, lines):\\n\\n data = []\\n curr = None\\n for line in lines:\\n line = self.clean_line(line)\\n\\n temp = []\\n quotes = 0\\n for item in line.split():\\n if quotes % 2 == 0:\\n temp.append(item)\\n else:\\n temp[-1] += item\\n quotes += item.count(\\\"\\\\\\\"\\\")\\n line = temp\\n\\n if not line:\\n continue\\n if curr:\\n if self.compare_keys(curr, line):\\n curr = self.merge_lines(curr, line)\\n else:\\n data.append(self.add_line(curr))\\n curr = line\\n else:\\n curr = line\\n if curr:\\n data.append(self.add_line(curr))\\n return data\",\n \"def _chop_end_misc(line):\\n return re.sub(r\\\"\\\\s+\\\\d\\\\d-\\\\w\\\\w\\\\w-\\\\d\\\\d\\\\s+[1-9][0-9A-Z]{3}\\\\s*\\\\Z\\\", \\\"\\\", line)\",\n \"def clean_serial_data(data):\\n clean_data = []\\n line_data = []\\n for line in data:\\n print (line)\\n #line = float(line)\\n clean_data.append(int(line)/1000)\\n \\n return clean_data\",\n \"def remove_line(self, origin):\\n current_tile = self.board[origin[0]][origin[1]]\\n\\n if current_tile.is_dot:\\n temp = current_tile.next\\n current_tile.next = None\\n current_tile = temp\\n\\n # Remove color of all non dot tiles in line.\\n while current_tile and current_tile.color and not current_tile.is_dot:\\n temp = current_tile.next\\n current_tile.color = None\\n current_tile.next = None\\n current_tile = temp\",\n \"def clean(self):\\n # Perform the standard ACE cleaning\\n max_status = mm_ace.clean(self)\\n\\n # Replace bad values with NaN and remove times with no valid data\\n ecols = ['eflux_38-53', 'eflux_175-315']\\n\\n # Evaluate the electron flux data\\n self[self.data['status_e'] > max_status, ecols] = np.nan\\n\\n # Evaluate the proton flux data\\n pcols = ['pflux_47-68', 'pflux_115-195', 'pflux_310-580',\\n 'pflux_795-1193', 'pflux_1060-1900']\\n self[self.data['status_p'] > max_status, pcols] = np.nan\\n\\n # Include both fluxes and the anisotropy index in the removal eval\\n eval_cols = ecols + pcols\\n eval_cols.append('anis_ind')\\n\\n # Remove lines without any good data\\n good_cols = (np.isfinite(self.data.loc[:, eval_cols])).sum(axis=1)\\n bad_index = good_cols[good_cols == 0].index\\n self.data = self.data.drop(index=bad_index)\\n\\n return\",\n \"def test_line_strip():\\n for _x in range(100):\\n l_str = \\\" \\\".join([random_str(5, 10) for x in range(30)])\\n l_str = (\\\" \\\" * randint(0, 10)) + l_str + (\\\" \\\" * randint(0, 10))\\n line = Line(l_str, random_str(10, 20), randint(1, 10000))\\n # Strip the string\\n l_stripped = line.strip()\\n assert l_stripped == l_str.strip()\\n assert isinstance(l_stripped, Line)\\n assert l_stripped.file == line.file\\n assert l_stripped.number == line.number\",\n \"def cleanData(rawData):\\n\\trawData = re.sub(r'R-LRB- \\\\(', r'R-LRB- -LRB-', rawData)\\n\\trawData = re.sub(r'R-RRB- \\\\)', r'R-RRB- -RRB-', rawData)\\n\\trawData = re.sub(r'R-RRB- \\\\(', r'R-RRB- -LRB-', rawData)\\n\\trawData = re.sub(r'-LRB- \\\\(', r'-LRB- -LRB-', rawData)\\n\\trawData = re.sub(r'-RRB- \\\\)', r'-RRB- -RRB-', rawData)\\n\\trawData = re.sub(r'PU \\\\(', r'PU -LRB-', rawData)\\n\\trawData = re.sub(r'PU \\\\)', r'PU -RRB-', rawData)\\n\\trawData = re.sub(r':-\\\\)', r'smileyface', rawData)\\n\\n\\treturn rawData\",\n \"def CleanLineEndings(aLine):\\n str = aLine.replace(cr, \\\"\\\") # remove cr\\n str = str.replace(lf, \\\"\\\") # remove lf\\n return str\",\n \"def clean_lines(df_column):\\n \\n clean_lines = []\\n # pattern for html tags\\n tag_match = re.compile('<.*?>')\\n # patterm for website\\n website_match = re.compile('https?:\\\\/\\\\/.*[\\\\r\\\\n]*')\\n # pattern for tex\\n tex_match = re.compile('\\\\$\\\\$?.+?\\\\$\\\\$?')\\n \\n for line in df_column:\\n s = re.sub(tag_match, '', line)\\n s = re.sub(website_match, '[website]', s)\\n s = re.sub(tex_match, '[tex]', s)\\n # replace extra whitespace with spaces\\n for x in string.whitespace:\\n s = s.replace(x, ' ')\\n clean_lines.append(s)\\n \\n return clean_lines\",\n \"def clean(df):\",\n \"def cleanup(segment):\\n cnt = ''.join(segment.file_content)\\n index = cnt.find('\\\\\\\\annotate')\\n if index < 0:\\n return\\n while index >= 0:\\n cnt, new_ind = parse_annotation(cnt, index)\\n index = cnt.find('\\\\\\\\annotate', new_ind)\\n f = codecs.open(segment.filename, 'w', 'utf-8')\\n f.write(cnt)\\n f.close()\\n info('Updated: {} {}'.format(segment.voice_name, segment.name))\",\n \"def clear(self) -> None:\\n self.raw = ''\\n self.extent = None # type: ignore[assignment]\\n self._lines = []\\n self.items = None\\n self.seen_headers = {}\\n return\",\n \"def clean_smile(self, smi):\\n smi = smi.replace('\\\\n', '')\\n return smi\",\n \"def clean_rows(reader):\\n return [[a.strip() for a in row] for row in reader if row]\",\n \"def clean_comments(self):\\n new_lines = list()\\n for line in self.lines:\\n if ((not line.startswith(\\\"//\\\")) & (not line.isspace()) &\\n (not line.startswith(\\\"/*\\\") & (not line.startswith(\\\"*/\\\")))):\\n line = Parser.strip_line(line)\\n new_lines.append(line)\\n self.lines = new_lines\",\n \"def pruneMarks(self):\\n self.__prune_marks(self.nodes(data=True))\",\n \"def clean(line):\\n line = line.strip('\\\\n').strip()\\n line = line.replace('\\\\xe2\\\\x80\\\\x93', '-')\\n line = line.replace('\\\\xe2\\\\x80\\\\x99', '\\\\'')\\n\\n return line\",\n \"def _rstrip(line, JUNK='\\\\n \\\\t'):\\r\\n\\r\\n i = len(line)\\r\\n while i > 0 and line[i-1] in JUNK:\\r\\n i -= 1\\r\\n return line[:i]\",\n \"def clean_textual_attributes(self):\\n for attribute in self.__textual_attributes:\\n for index, text in self.__df[attribute].dropna().iteritems():\\n text = remove_non_printable_characters(text)\\n text = remove_html_tags(text)\\n text = remove_unnecessary_spaces(text)\\n self.__df.at[index, attribute] = text\",\n \"def experience_clean_row(row_of_data):\\n experience = row_of_data.get('experience')\\n z = list(set(remove_filler_words(experience)))\\n return z\",\n \"def drop_little_line(data, seuil):\\n idx = []\\n\\n for i, line in enumerate(data.abstract):\\n if len(line.split()) < seuil:\\n idx.append(i)\\n data.drop(data.index[idx])\\n data.index = range(len(data.index))\\n return data\",\n \"def minimal_clean_data_inplace(df):\\n # There are some 'unknown' users in train dataset only\\n unknown_data_lines = df['sexo'].isnull() & df['age'].isnull() & df['ind_empleado'].isnull() & \\\\\\n df['fecha_alta'].isnull() & df['pais_residencia'].isnull()\\n\\n logging.info(\\\"- Number of lines with unknown data : %s\\\" % unknown_data_lines.sum())\\n\\n # Remove these users as clients\\n _clients = df[unknown_data_lines]['ncodpers'].unique()\\n bad_lines = df['ncodpers'].isin(_clients)\\n df.drop(df[bad_lines].index, inplace=True)\\n\\n logging.info(\\\"- Number of columns with nan : %s\\\" % df.isnull().any().sum())\\n\\n # Remove accent\\n df.loc[df['nomprov'] == \\\"CORU\\\\xc3\\\\x91A, A\\\", \\\"nomprov\\\"] = \\\"CORUNA\\\"\\n\\n unknown_cols = ['sexo',\\n 'ind_empleado',\\n 'pais_residencia',\\n 'ult_fec_cli_1t',\\n 'conyuemp',\\n 'canal_entrada',\\n 'nomprov',\\n 'segmento',\\n 'tiprel_1mes',\\n 'indrel_1mes']\\n # Start with cols -> replace nan with UNKNOWN\\n for col in unknown_cols:\\n df.loc[df[col].isnull(), col] = \\\"UNKNOWN\\\"\\n\\n # Set unknown renta to -99\\n df.loc[df['renta'].isnull(), 'renta'] = -99\\n\\n # Next `fecha_alta` :\\n assert df['fecha_alta'].isnull().sum() == 0, \\\\\\n \\\"Need to replace nan in 'fecha_alta', count=%s\\\" % df['fecha_alta'].isnull().sum()\\n\\n # **Remove 'tipodom' and 'cod_prov' columns**\\n df.drop([\\\"tipodom\\\", \\\"cod_prov\\\"], axis=1, inplace=True)\\n \\n # Convert 'ind_nuevo' to int\\n df['ind_nuevo'] = df['ind_nuevo'].astype(int)\\n \\n # Remove floating point at string indrel_1mes\\n df['indrel_1mes'] = df['indrel_1mes'].apply(lambda x: str(int(float(x))) if len(x) == 3 else x)\\n\\n if \\\"ind_nomina_ult1\\\" in df.columns and \\\"ind_nom_pens_ult1\\\" in df.columns:\\n # Target labels : `ind_nomina_ult1`, `ind_nom_pens_ult1` : nan -> 0\\n # I could try to fill in missing values for products by looking at previous months,\\n # but since it's such a small number of values for now I'll take the cheap way out.\\n df.loc[df.ind_nomina_ult1.isnull(), \\\"ind_nomina_ult1\\\"] = 0\\n df.loc[df.ind_nom_pens_ult1.isnull(), \\\"ind_nom_pens_ult1\\\"] = 0\\n\\n # replace 'antiguedad' with the number of months between 'fecha_alta' and 'fecha_dato'\\n func1 = lambda x: _to_ym_dec(to_yearmonth(x))\\n func2 = lambda x: max(_to_nb_months(x), 0) \\n\\n v1 = df['fecha_dato'].apply(func1)\\n v2 = df['fecha_alta'].apply(func1)\\n v3 = (v1 - v2).apply(func2)\\n df.loc[:, 'antiguedad'] = v3\\n \\n # Replace 'ult_fec_cli_1t' by current nb of months from fecha_dato, if negative, set to zero\\n mask = df['ult_fec_cli_1t'] == 'UNKNOWN'\\n df.loc[mask, 'ult_fec_cli_1t'] = df[mask]['fecha_dato']\\n v1 = df['fecha_dato'].apply(func1)\\n v2 = df['ult_fec_cli_1t'].apply(func1)\\n v3 = (v1 - v2).apply(func2)\\n df.loc[:, 'ult_fec_cli_1t'] = v3\",\n \"def remove_line(self, id):\\n id = id_force_tuple(id)\\n prf = self.prf.get_parent_proof(id)\\n split = id[-1]\\n prf.items = prf.items[:split] + prf.items[split+1:]\\n for item in prf.items[split:]:\\n decr_proof_item(item, id)\\n\\n self.check_proof(compute_only=True)\",\n \"def cleanGpt2Prediction(input_text, prediction):\\n if input_text and input_text[-1] != \\\" \\\": input_text += \\\" \\\"\\n prediction = input_text + prediction.strip()\\n cutted = \\\"\\\"\\n if prediction[-1] != '.':\\n last_dot_idx = prediction.rfind('. ')\\n if last_dot_idx != -1:\\n cutted = prediction[last_dot_idx + 1:]\\n prediction = prediction[:last_dot_idx + 1]\\n print(f\\\"\\\"\\\"{'='*20}\\\\n-> Removed:\\\\n|{cutted}|\\\\nat the end of prediction\\\"\\\"\\\")\\n res = [line for line in prediction.split('\\\\n') if line and line.strip()[0] != '\\\"']\\n return '\\\\n'.join(res)\",\n \"def _(event):\\n deleted = line.delete_before_cursor(count=-line.document.get_start_of_line_position())\\n line.set_clipboard(ClipboardData(deleted))\",\n \"def strip_line_ending( line ):\\n\\n # surely there's a better way?\\n while len(line) and line[-1] in '\\\\n\\\\r':\\n line = line[:-1]\\n\\n while len(line) and line[0] in '\\\\n\\\\r':\\n line = line[1:]\\n \\n return line\",\n \"def strip(self):\\n self.document_type = self.document_type.strip()\\n self.document_reg_id = self.document_reg_id.strip()\\n self.owner_cross_reference = self.owner_cross_reference.strip()\\n self.routing_slip_number = self.routing_slip_number.strip()\\n self.bcol_account = self.bcol_account.strip()\\n self.dat_number = self.dat_number.strip()\\n self.examiner_id = self.examiner_id.strip()\\n self.update_id = self.update_id.strip()\\n self.phone_number = self.phone_number.strip()\\n self.attention_reference = self.attention_reference.strip()\\n self.name = self.name.strip()\\n self.legacy_address = self.legacy_address.strip()\\n self.consideration_value = self.consideration_value.strip()\\n self.affirm_by_name = self.affirm_by_name.strip()\\n self.liens_with_consent = self.liens_with_consent.strip()\\n self.client_reference_id = self.client_reference_id.strip()\\n self.own_land = self.own_land.strip()\",\n \"def remove_line(self, hash_code):\\n line_index = None\\n marker_index = None\\n\\n for i, lines in enumerate(self._lines):\\n for j, line in enumerate(lines):\\n if hash_graphics_line(line) == hash_code:\\n marker_index = j\\n line_index = i\\n\\n if line_index is None or marker_index is None:\\n return None\\n\\n del self._lines[line_index][marker_index]\\n self.set_changed()\\n\\n if len(self._lines[line_index]) == 0:\\n del self._lines[line_index]\\n return None\\n\\n return self._lines[line_index]\",\n \"def clean_data(data):\\n src_list = []\\n no_net_view = []\\n for row in range(data.nrows):\\n # Ignore header row.\\n if row == 0:\\n continue\\n # Ignore blank row.\\n if data.row_values(row)[1] == '' and \\\\\\n data.row_values(row)[15] == '':\\n continue\\n # Capture lines that do not have a view listed.\\n if data.row_values(row)[1] and not data.row_values(row)[15]:\\n no_net_view.append(data.row_values(row))\\n continue\\n src_list.append(data.row_values(row))\\n\\n # Clean's src_list values.\\n src_list = [[item.replace('\\\\t', '') for item in row\\n if isinstance(item, str)]\\n for row in src_list]\\n src_list = [[item.replace('\\\\n', ', ') for item in row\\n if isinstance(item, str)]\\n for row in src_list]\\n src_list = [[item.replace(', ,', ', ') for item in row\\n if isinstance(item, str)]\\n for row in src_list]\\n src_list = [[item.strip() for item in row\\n if isinstance(item, str)]\\n for row in src_list]\\n for enum, row in enumerate(src_list):\\n row[0] = row[0].lower()\\n src_list[enum] = row\\n return src_list\",\n \"def remove(self, from_line, from_col, to_line, to_col):\\n assert from_line == to_line\\n from_col = self.canonicalize_column_index(from_line, from_col)\\n to_col = self.canonicalize_column_index(to_line, to_col)\\n\\n col_off = self.col_offs[from_line]\\n adj_from_col = col_off.get_rewritten_pos(from_col)\\n adj_to_col = col_off.get_rewritten_pos(to_col)\\n theline = self.lines[from_line]\\n self.lines[from_line] = theline[:adj_from_col] + theline[adj_to_col:]\\n col_off.remove(from_col, to_col-from_col)\",\n \"def _clean_data(self):\\n if not path.exists('auto-mpg.data.txt'):\\n logger.info('Could not find auto-mpg.data.txt in the current working directory')\\n sys.exit()\\n else:\\n try:\\n with open('auto-mpg.data.txt', 'r') as dirty_data:\\n with open('auto-mpg.clean.txt', 'w') as clean_data:\\n ## counter for row writes\\n counter = 0\\n for row in csv.reader(dirty_data):\\n clean_data.write(row[0].expandtabs(1) + '\\\\n')\\n counter +=1\\n except Exception as e:\\n logger.info('File error occurred: {e}. Exiting')\\n sys.exit()\",\n \"def _strip_lines(lines):\\n for line in lines:\\n stripped = line.strip()\\n if stripped:\\n yield stripped\",\n \"def reset_annotations(self):\\n # FIXME: this state does not make sense\\n self.annotation_date_set = False\\n self.annotation_comment_set = False\\n self.annotation_type_set = False\\n self.annotation_spdx_id_set = False\",\n \"def unlines(line):\\n\\n return line.translate(str.maketrans('\\\\n', ' '))\",\n \"def cleaned_contents(self):\\n snip_with_code = re.compile(\\\"(//.*snip(\\\\-file)*:?.*\\\\n)(\\\\+\\\\n)?(\\\\[.*\\\\]\\\\n)*----\\\\n(.*\\\\n)*?----\\\\n\\\", flags=re.IGNORECASE)\\n cleaned = re.sub(snip_with_code, r'\\\\1', self.contents)\\n return cleaned\",\n \"def clean_data(self):\\n data_clean = []\\n for item in self.data:\\n if int(item[2]) >= self.seq_length and int(item[2]) <= self.max_frames:# and item[1] in self.classes:\\n data_clean.append(item)\\n\\n return data_clean\",\n \"def clean(args):\\n with_dataset(args, Dataset._clean)\",\n \"def education_clean_row(row_of_data):\\n education = row_of_data.get('education')\\n z = list(set(remove_filler_words(education)))\\n return z\",\n \"def _strip_once(value):\\n s = MLStripper()\\n s.feed(value)\\n s.close()\\n return s.get_data()\",\n \"def applyMorphologicalCleaning(self, image):\",\n \"def remove_comments(line):\\n hashPos = line.find('#')\\n return line[:hashPos] if hashPos >= 0 else line\",\n \"def clean(datapath):\\n red_flags = ['â€', 'Â']\\n\\n with open(datapath, 'r') as file:\\n data = json.load(file)\\n\\n bad = []\\n good = []\\n for article in progress(data, 'Fixing {0} articles...'.format(len(data))):\\n for key in ['title', 'text']:\\n article[key] = fix_text_segment(article[key])\\n\\n flagged = False\\n for flag in red_flags:\\n if flag in article['text'] + article['title']:\\n bad.append(article)\\n flagged = True\\n break\\n if not flagged:\\n good.append(article)\\n\\n print('Getting rid of {0} bad articles.'.format(len(bad)))\\n\\n outpath = datapath.replace('.json', '_cleaned.json')\\n with open(outpath, 'w') as file:\\n json.dump(good, file)\",\n \"def strip_comments(line):\\n if \\\"#\\\" in line:\\n return line[:line.find(\\\"#\\\")]\\n else:\\n return line\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65842664","0.6322053","0.61243117","0.6106798","0.6106798","0.6087376","0.60553944","0.5906017","0.5889315","0.5888119","0.58622","0.58618647","0.58282447","0.58261687","0.5818282","0.58130705","0.57777137","0.5760969","0.57328576","0.57266486","0.5716569","0.5714271","0.5655816","0.5653608","0.56232756","0.5597971","0.5590046","0.558328","0.5564838","0.5535715","0.55310595","0.55267656","0.55124736","0.55076724","0.5506068","0.54923844","0.5490053","0.5455799","0.54330385","0.54263836","0.54222393","0.5422164","0.54146314","0.541215","0.5403055","0.5395121","0.5388865","0.53869873","0.5381728","0.5363039","0.53541136","0.5352374","0.5351252","0.5344728","0.5342233","0.53421617","0.5333348","0.53190917","0.53185266","0.5311936","0.53043824","0.52966964","0.5283882","0.5266071","0.52626795","0.5252717","0.5249984","0.5243088","0.52323174","0.5226279","0.52212673","0.52186567","0.52183056","0.52108246","0.5202519","0.5193992","0.5192132","0.51915854","0.5189797","0.51839656","0.51836866","0.5181604","0.51642716","0.51635385","0.51583624","0.5154828","0.5154152","0.5147709","0.514597","0.51426816","0.5119757","0.5114575","0.5110482","0.510176","0.50974315","0.5089471","0.50836194","0.5077082","0.5071092","0.5069919"],"string":"[\n \"0.65842664\",\n \"0.6322053\",\n \"0.61243117\",\n \"0.6106798\",\n \"0.6106798\",\n \"0.6087376\",\n \"0.60553944\",\n \"0.5906017\",\n \"0.5889315\",\n \"0.5888119\",\n \"0.58622\",\n \"0.58618647\",\n \"0.58282447\",\n \"0.58261687\",\n \"0.5818282\",\n \"0.58130705\",\n \"0.57777137\",\n \"0.5760969\",\n \"0.57328576\",\n \"0.57266486\",\n \"0.5716569\",\n \"0.5714271\",\n \"0.5655816\",\n \"0.5653608\",\n \"0.56232756\",\n \"0.5597971\",\n \"0.5590046\",\n \"0.558328\",\n \"0.5564838\",\n \"0.5535715\",\n \"0.55310595\",\n \"0.55267656\",\n \"0.55124736\",\n \"0.55076724\",\n \"0.5506068\",\n \"0.54923844\",\n \"0.5490053\",\n \"0.5455799\",\n \"0.54330385\",\n \"0.54263836\",\n \"0.54222393\",\n \"0.5422164\",\n \"0.54146314\",\n \"0.541215\",\n \"0.5403055\",\n \"0.5395121\",\n \"0.5388865\",\n \"0.53869873\",\n \"0.5381728\",\n \"0.5363039\",\n \"0.53541136\",\n \"0.5352374\",\n \"0.5351252\",\n \"0.5344728\",\n \"0.5342233\",\n \"0.53421617\",\n \"0.5333348\",\n \"0.53190917\",\n \"0.53185266\",\n \"0.5311936\",\n \"0.53043824\",\n \"0.52966964\",\n \"0.5283882\",\n \"0.5266071\",\n \"0.52626795\",\n \"0.5252717\",\n \"0.5249984\",\n \"0.5243088\",\n \"0.52323174\",\n \"0.5226279\",\n \"0.52212673\",\n \"0.52186567\",\n \"0.52183056\",\n \"0.52108246\",\n \"0.5202519\",\n \"0.5193992\",\n \"0.5192132\",\n \"0.51915854\",\n \"0.5189797\",\n \"0.51839656\",\n \"0.51836866\",\n \"0.5181604\",\n \"0.51642716\",\n \"0.51635385\",\n \"0.51583624\",\n \"0.5154828\",\n \"0.5154152\",\n \"0.5147709\",\n \"0.514597\",\n \"0.51426816\",\n \"0.5119757\",\n \"0.5114575\",\n \"0.5110482\",\n \"0.510176\",\n \"0.50974315\",\n \"0.5089471\",\n \"0.50836194\",\n \"0.5077082\",\n \"0.5071092\",\n \"0.5069919\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6030962"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":3197,"cells":{"query":{"kind":"string","value":"Returns the accounting period that is currently valid. Valid is an accounting_period when the current date lies between begin and end of the accounting_period"},"document":{"kind":"string","value":"def get_current_valid_accounting_period():\n current_valid_accounting_period = None\n for accounting_period in AccountingPeriod.objects.all():\n if accounting_period.begin < date.today() and accounting_period.end > date.today():\n return accounting_period\n if not current_valid_accounting_period:\n raise AccountingPeriodNotFound()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getCurrentValidAccountingPeriod():\n currentValidAccountingPeriod = None\n for accountingPeriod in AccountingPeriod.objects.all():\n if accountingPeriod.begin < date.today() and accountingPeriod.end > date.today():\n return accountingPeriod\n if currentValidAccountingPeriod == None:\n raise NoFeasableAccountingPeriodFound()","def get_current_period(self):\n if not self.next_billing:\n return None\n assert self.type == \"N\", _(\"Subscription must be normal to use this method\")\n start = self.next_billing - relativedelta(months=self.frequency)\n end = self.next_billing\n return start, end","def current_period(self):\n return self._current_period","def get_all_prior_accounting_periods(target_accounting_period):\n accounting_periods = []\n for accounting_period in AccountingPeriod.objects.all():\n if accounting_period.end < target_accounting_period.begin:\n accounting_periods.append(accounting_period)\n if accounting_periods == []:\n raise AccountingPeriodNotFound(\"Accounting Period does not exist\")\n return accounting_periods","def getAllPriorAccountingPeriods(targetAccountingPeriod):\n currentValidAccountingPeriod = None\n accountingPeriods = []\n for accountingPeriod in AccountingPeriod.objects.all():\n if accountingPeriod.end < targetAccountingPeriod.begin:\n accountingPeriods.append(accountingPeriod)\n if accountingPeriods == []:\n raise NoPriorAccountingPeriodFound()\n return accountingPeriods","def period(self):\n return self.__period","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def __get_period(self):\n return self.__period","def get_chart_period(self,req):\n now=int(DATE())\n period=INT(req.period) # allow for it having been a string\n if period>9999: # assume it is a month\n if period<(now//100): # a valid complete previous month\n prior=True# this is a previous month\n else:\n period=now//100 # default to current month\n prior=False\n start=period*100+1\n end=self.nextperiod(period)*100+1\n else: # assume it is a year\n if period and (period<(now//10000)): # a prior year\n prior=True# this is a previous year\n else:\n##\n# period=now//100 # default to current month\n# prior=False\n# start=period*100+1\n# end=self.nextperiod(period)*100+1\n##\n period=now//10000 # default to current year\n prior=False\n start=period*10000+101\n end=self.nextperiod(period)*10000+101\n return period,start,end,prior","def planning_period(self):\n return self._planning_period","def getPeriod(self):\n return StripePeriod(self.base.get(\"period\", []))","def billing_period(self) -> Optional[str]:\n return pulumi.get(self, \"billing_period\")","def get_interval(self):\n return self._period","def get_period(self):\n # res\n if self._cacheExpiration <= YAPI.GetTickCount():\n if self.load(YAPI._yapiContext.GetCacheValidity()) != YAPI.SUCCESS:\n return YPwmOutput.PERIOD_INVALID\n res = self._period\n return res","def get_period_guarantee_faithful_compliance(self):\n return ceiling(self.get_period_faithful_compliance, 3)","def remaining_days_in_current_period(self):\n try:\n return self.count_days_from_now(self.current_period_ends_at)\n except AttributeError:\n return 0","def get_period_range(self, period, start, end, inclusive_start=True, inclusive_end=True):\n if not isinstance(start, datetime.datetime):\n start = self.get_date_from_string(start, '%Y-%m-%d')\n if not isinstance(end, datetime.datetime):\n end = self.get_date_from_string(end, '%Y-%m-%d')\n\n if period == 'month':\n get_period = self.get_current_month_range\n get_next_period = self.get_next_month\n get_previous_period = self.get_previous_month\n if period == 'week':\n get_period = self.get_current_week_range\n get_next_period = self.get_next_week\n get_previous_period = self.get_previous_week\n\n #####################\n # inclusive_start means that the result set will include the whole period\n # containing the start date. Likewise for inclusive_end.\n #\n # If you are, say, reporting on a 'last completed month' or something,\n # but your report date (and end date) is mid-month or something, then setting 'inclusive_end'\n # to False will insure that the report ends with the month prior to the\n # end date.\n #\n # If you're doing projections starting with the month following the one\n # you're in, setting inclusive_start to False will insure that the first\n # period in the range is the one *after* the period you're in now.\n #######################\n if not inclusive_start:\n start = get_next_period(start)[0]\n if not inclusive_end:\n end = get_previous_period(end)[1]\n\n returnvals = []\n\n\n firstper = get_period(start)\n returnvals.append(firstper)\n per = firstper\n while per[1] < end:\n # goes as long as the *end* of the period is < our end date.\n # the intent is that if end is 2010-10-04, the last period will be\n # (2010-10-01, 2010-10-31)\n per = get_next_period(per[1])\n returnvals.append(per)\n\n return returnvals","def checkpoint_period_get(self):\n raise Exception(\"TODO\")","def expected_last_period_end(self):\n return self._expected_last_period_end","def valid_period(request):\n return request.param","def _get_period(self, cr, uid, context={}):\n\n account_period_obj = self.pool.get('account.period')\n ids = account_period_obj.find(\n cr, uid, time.strftime('%Y-%m-%d'), context=context)\n period_id = ids[0]\n return period_id","def real_period(self):\n return max(\n self.period * self.PERIOD_MARGIN_FACTOR -\n (self.max_lag if self.max_lag else self.lag * self.LAG_MARGIN_FACTOR),\n 0.0)","def getBeginEnd(self):\n if (self.dr_type == choices.DATE_RANGE_TYPE_FIXED):\n return self.begin, self.end\n\n elif (self.dr_type == choices.DATE_RANGE_TYPE_VARIABLE):\n end = datetime.now()\n\n if (self.unit == choices.TIME_UNIT_DAY):\n begin = end - relativedelta(days=self.quantity)\n\n elif (self.unit == choices.TIME_UNIT_WEEK):\n begin = end - relativedelta(weeks=self.quantity)\n\n elif (self.unit == choices.TIME_UNIT_MONTH):\n begin = end - relativedelta(months=self.quantity)\n\n elif (self.unit == choices.TIME_UNIT_YEAR):\n begin = end - relativedelta(years=self.quantity)\n\n else:\n # This case should not happen\n raise Exception(\"A DateRange object's 'unit' must be a numeric\"\n \" value in: {units}.\".format(units=\", \".join([\n \"{const} ({name})\".format(const=unit, name=unit_name)\n for unit, unit_name in choices.TIME_UNIT\n if unit is not None]))\n )\n\n return begin, end\n\n else:\n # This case should not happen\n raise Exception(\"A DateRange object's 'dr_type' must be one of:\"\n \" {const_fixed} (fixed range) or {const_dynamic}\"\n \" (dynamic range).\".format(\n const_fixed=choices.DATE_RANGE_TYPE_FIXED,\n const_dynamic=choices.DATE_RANGE_TYPE_VARIABLE\n ))","def period(self) -> int:","def get_period_guarantee_advance(self):\n return ceiling(self.scheduled_completion, 3)","def renewal_period(self) -> Optional[float]:\n return pulumi.get(self, \"renewal_period\")","def get_first_period(start_record, end_record, start_period, end_period):\n start_record, end_record, start_period, end_period = to_datetime(start_record, end_record, start_period, end_period)\n pspan = end_period - start_period\n delta_year = relativedelta(years=1)\n # what is the first day of year of the start of the period that fits the record?\n start_rec_year = start_record.year\n d = datetime(start_rec_year, start_period.month, start_period.day)\n if d < start_record:\n d = d + delta_year\n delta_years = start_period.year - d.year\n e = end_period + relativedelta(years=-delta_years)\n return (d, e)","def periodCheck(data):","def date_validity(self):\n return self._date_validity","def _get_period(self, cr, uid, context=None):\n context = context or {}\n if context.get('period_id', False):\n return context['period_id']\n account_period_obj = self.pool.get('account.period')\n ctx = dict(context, account_period_prefer_normal=True)\n ids = account_period_obj.find(cr, uid, context=ctx)\n period_id = False\n if ids:\n period_id = ids[0]\n return period_id","def between(cls, begin_date: datetime.date, end_date: datetime.date) -> float:\n\n if begin_date > end_date:\n raise ValueError('End date must not be before begin date.')\n if begin_date == end_date:\n return 0\n data = cls.cumulative()\n first = data.get((begin_date.year, begin_date.month), None)\n last = data.get((end_date.year, end_date.month), None)\n if first is None or last is None:\n raise ValidationError(\"Inflation figures don't cover entire period requested: {} - {}\".format(begin_date,\n end_date))\n return (last / first) - 1","def orbital_period(self):\n return self._orbital_period","def valid_until(self) -> datetime:\n return self._valid_until","def current(self) -> Optional['outputs.CommitmentPeriodResponse']:\n return pulumi.get(self, \"current\")","def _period_from_date(self):\n if self.date['year']:\n if self.date['month']:\n if self.date['day']:\n self.period = Period.DAILY\n else:\n self.period = Period.MONTHLY\n else:\n self.period = Period.YEARLY\n else:\n self.period = Period.FULL","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def test_list_grading_periods_accounts(self):\r\n account_id = None # Change me!!\r\n\r\n r = self.client.list_grading_periods_accounts(account_id)","def get_period_budgets(cls, now):\n limits_dict = {}\n strategies = cls.objects_visible.filter(is_distributed_evenly=True)\n strategies = cls.running(strategies)\n\n for strategy in strategies:\n limits_dict[strategy.public_id] = strategy.period_budget(now)\n\n log.info('[SPENDINGS] Period budgets calculated (currency): {0}'.format(limits_dict))\n\n # Cast to budget precision used in Redis\n return {strategy: cast_CPM_to_dbbid(cast_currency_to_CPM(budget)) for strategy, budget in limits_dict.items()}","def billing_period_start(self): # ISO8601 or timestamp\n return self._safe_value(VAR_BILLINGPERIODSTART, int)","def amount_to_pay_in_period(self):\n assert self.type == \"N\", _(\"Subscription must be normal to use this method\")\n period_start, period_end = self.get_current_period()\n price_per_day = (\n self.get_price_for_full_period() / (period_end - period_start).days\n )\n days_not_used = 30 * self.frequency - (date.today() - period_start).days\n return int(price_per_day * days_not_used)","def current_effective_deadline(cls) -> float:","def get_periods():\n return [\n relativedelta(),\n relativedelta(days=6),\n relativedelta(months=1),\n relativedelta(months=3),\n relativedelta(years=1),\n relativedelta(years=5)\n ]","def get_period(self):\n raise NotImplementedError('Agent is an abstract base class')","def block_period_consumption(self):\n return self._safe_value(VAR_BLOCKPERIODCONSUMPTION, float)","def get_last_period(self, status_id, company_payroll_id, config=None):\n if not config:\n config = self.env['ka_hr_payroll.config'].default_config()\n\n date_now = datetime.now().date()\n date_config = datetime.strptime(\"{0}-{1}-{2}\".format(date_now.year, date_now.month, config.date_start),\n DATE_FORMAT)\n date_config_str = date_config.strftime(DATE_FORMAT)\n\n return self.search([\n ('date_start', '<=', fields.Date.today()),\n ('status_id', 'parent_of', status_id),\n ('state', '=', 'done'),\n ('state_rapel', '!=', '1'),\n ('date_done', '<', date_config_str),\n ('company_payroll_id', '=', company_payroll_id)\n ], limit=1, order='date_start desc')","def remaining_days(self):\n if self.trialing or self.trial_ended:\n return self.remaining_trial_days\n else:\n return self.remaining_days_in_current_period","def period(self):\n return float(self._period) / 1000","def sleepPeriodValidate(self):\n # sleep_validate = False (not in sleep period)\n # sleep_validate = True (in sleep period)\n \n sleep_validate = None\n pre_midnight = '23:59'\n midnight = '00:00'\n \n # check if out of sleep period\n if self.current_time >= self.sleep_stop and self.current_time < self.sleep_start:\n sleep_validate = False\n \n # check if in sleep period\n elif self.current_time >= self.sleep_start and self.current_time <= pre_midnight:\n sleep_validate = True \n elif self.current_time < self.sleep_stop and self.current_time > midnight:\n sleep_validate = True\n \n return sleep_validate","def getUpdatePeriod( self, obj=None ):\n if obj is not None:\n period = self.getSyndicationInfo(obj).period\n else:\n period = self.period\n return period","def kind(self):\n return DateValueTypes.PERIOD","def get_current_fiscal_year(self):\n current_date = datetime.today().date()\n for year in self.fiscal_years.all():\n if year.begin_date < current_date < year.end_date:\n return year\n return None","def dispatch_interval(self):\n start = self.start\n start_date = start.date()\n\n # add zero padding to make period_id 3 chars long\n period_id = str(self.period_id).zfill(3)\n\n if start.hour < 4 and period_id != \"001\":\n start_date = start_date - timedelta(days=1)\n\n # Concat zero-padded dates and add period id\n dispatch_interval = \"\".join([start_date.strftime(\"%Y%m%d\"), period_id])\n\n return dispatch_interval","def InactiveNoEndDate(obj):\n if not obj.active_p:\n if not (obj.end_date):\n raise interface.Invalid(\n _(\"If a person is inactive End Date must be set\"), \n \"end_date\", \n \"active_p\")","def in_grace_period_count(self):\n if \"inGracePeriodCount\" in self._prop_dict:\n return self._prop_dict[\"inGracePeriodCount\"]\n else:\n return None","def get_employees_born_in_period(cls, start_date, end_date,\n strategy=lazyload):\n cls._check_strategy(strategy)\n\n employees = db.session.query(Employee).options(\n strategy(Employee.department)\n ).filter(\n and_(\n Employee.date_of_birth > start_date,\n Employee.date_of_birth < end_date\n )\n ).all()\n return employees","def _get_default_period(self, cr, uid, context=None):\n context = context or {}\n if context.get('period_id', False):\n return context['period_id']\n account_period_obj = self.pool.get('account.period')\n ctx = dict(context, account_period_prefer_normal=True)\n ids = account_period_obj.find(cr, uid, context=ctx)\n period_id = False\n if ids:\n period_id = ids[0]\n return period_id","def validate_check_in_period(check_in_period):\n if not check_in_period:\n check_in_period = 30\n if not isinstance(check_in_period, int):\n try:\n check_in_period = int(check_in_period)\n except ValueError:\n print \"Incorrect check-in period given. Setting to 30.\"\n check_in_period = 30\n\n return check_in_period","def find_period_below(self, start, end, target, length):\n\n if start > end:\n raise ValueError(\"End needs to be after start!\")\n if length < 0:\n raise ValueError(\"Period length must be larger than zero!\")\n\n period_start = (start if self.get(start) <= target else None)\n\n start_ix = self._trace.bisect_right(start)\n end_ix = self._trace.bisect_left(end)\n for time, lvl in self._trace.items()[start_ix:end_ix]:\n # Period long enough?\n if period_start is not None:\n if time >= period_start + length:\n return period_start\n # Not enough space until end?\n elif time + length > end:\n return None\n # Above target? Reset period\n if lvl > target:\n period_start = None\n else:\n if period_start is None:\n period_start = time\n\n # Possible at end?\n if period_start is not None and period_start+length <= end:\n return period_start\n\n # Nothing found\n return None","def valid_until(self):\n return self._valid_until / 10000000","def get_period(self, df, key):\n daysFiltered = self.filter_days(df, **self.periods[key]['days'])\n perStart = string_date(self.periods[key]['dates'][0], df.index[0].date().year)\n perEnd = string_date(self.periods[key]['dates'][1], df.index[0].date().year)\n if self.spans_year(key):\n # slice period for beginning of the year\n fall = daysFiltered.ix[perStart:string_date('12/31', df.index[0].date().year)]\n fall = fall.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\n fall = fall.sort_index()\n # slice period for end of the year\n spring = fall.append(daysFiltered.ix[string_date('1/1', df.index[0].date().year):perEnd])\n spring = spring.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\n spring = spring.sort_index()\n return(spring.rename_axis({'data': key}, axis=1))\n else:\n df_temp = daysFiltered.ix[perStart:perEnd]\n df_temp = df_temp.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\n return(df_temp.rename_axis({'data': key}, axis=1))","def get_debt_state(member, limit_year, limit_month):\n if member.first_payment_year is None:\n # never paid! using registration date to start with\n yearmonths_paid = set()\n year_to_check = member.registration_date.year\n month_to_check = member.registration_date.month\n else:\n # build a set for the year/month of paid quotas\n quotas = Quota.objects.filter(member=member).all()\n yearmonths_paid = {(q.year, q.month) for q in quotas}\n\n year_to_check = member.first_payment_year\n month_to_check = member.first_payment_month\n\n # verify the limit is after member started paying\n if year_to_check == limit_year:\n if month_to_check > limit_month:\n return []\n elif year_to_check > limit_year:\n return []\n\n # build a set of all the year/month the member should have paid up to (including) the limit\n should_have_paid = set()\n while True:\n should_have_paid.add((year_to_check, month_to_check))\n year_to_check, month_to_check = increment_year_month(year_to_check, month_to_check)\n if year_to_check == limit_year:\n if month_to_check > limit_month:\n break\n elif year_to_check > limit_year:\n break\n\n return sorted(should_have_paid - yearmonths_paid)","def period_check(init_dates, fcst_dates):\n check_dates(init_dates)\n check_dates(fcst_dates)\n \n if max(init_dates) > min(fcst_dates):\n raise ValueError('Forecast date, %s comes before initialisation '\\\n 'date, %s.' % (min(fcst_dates), max(init_dates)))\n\n fcst_dates = change_zeroth_hour(fcst_dates)\n return init_dates, fcst_dates","def period(self):\n return f\"{self.measurement_date.year}/{self.measurement_date.month}\"","def determine_periods(obj):\n return obj[len(obj)-1][\"period\"]","def pnl(qbo_session, period = \"YEARLY\", start_date=\"first\", end_date=\"last\",\n **kwargs):\n\n pnl_account_types = [\n \n \"Income\", \"Other Income\",\n \"Expense\", \"Other Expense\", \"Cost of Goods Sold\"\n \n ]\n\n \n\n # go through the accounts, collecting a list of those that are \n # pnl accounts\n\n relevant_accounts = []\n\n coa = qbo_session.chart_of_accounts()\n\n AccountType_i = coa[0].index(\"AccountType\")\n fqa_i = coa[0].index(\"FullyQualifiedName\")\n\n for a in coa:\n\n AccountType = a[AccountType_i]\n\n if AccountType in pnl_account_types:\n\n relevant_accounts.append(a[fqa_i])\n \n # now collect the ledger_lines that are even relevant to the time\n # period and pnl accounts (and we'll handle presentation last)\n\n relevant_activity = {} #{account:[relevant lines]}\n\n all_ledger_lines = qbo_session.ledger_lines(None, None, None, True,\n **kwargs)\n\n headers = all_ledger_lines[0]\n\n account_i = headers.index(\"account\") \n amount_i = headers.index(\"amount\")\n date_i = headers.index(\"TxnDate\")\n \n earliest_date = datetime(2100,1,1)\n latest_date = datetime(1900,1,1)\n\n for line in all_ledger_lines[1:]:\n\n account = line[account_i]\n line_date = line[date_i]\n\n #first apply the date filter!\n if not start_date == \"first\" and line_date < start_date:\n continue\n \n if not end_date == \"last\" and line_date > end_date:\n continue\n \n #if it's made the cut, we can update the report date bounds\n earliest_date = min(line_date,earliest_date)\n latest_date = max(line_date,latest_date)\n\n #then apply the account filter!\n\n if not account in relevant_activity:\n #then let's confirm that its account type is a pnl one\n \n if not account in relevant_accounts:\n \n continue\n\n else:\n relevant_activity[account] = []\n\n relevant_activity[account].append(line)\n\n #now let's do presentation\n #TODO -- incorporate pandas tables...do only minimal work on it until then\n\n pnl_lines = []\n\n if period == \"YEARLY\":\n\n report_start_date = datetime(earliest_date.year,1,1)\n report_end_date = datetime(latest_date.year,12,31)\n\n period_start_dates = list(rrule(YEARLY, bymonth=1, bymonthday=1,\n dtstart=report_start_date,\n until=report_end_date))\n\n period_end_dates = list(rrule(YEARLY, bymonth=12, bymonthday=-1,\n dtstart=report_start_date,\n until=report_end_date))\n\n elif period == \"MONTHLY\":\n\n report_start_date = datetime(earliest_date.year,\n earliest_date.month,\n 1)\n report_end_date = datetime(latest_date.year,\n latest_date.month,\n calendar.monthrange(latest_date.year,\n latest_date.month)[1])\n\n period_start_dates = list(rrule(MONTHLY, bymonthday=1,\n dtstart=report_start_date,\n until=report_end_date))\n\n period_end_dates = list(rrule(YEARLY, bymonthday=-1,\n dtstart=report_start_date,\n until=report_end_date)) \n\n header_1 = [\"\", \"Period Start -->\"] + period_start_dates\n header_2 = [\"Account\", \"Period End -->\"] + period_end_dates\n\n pnl_lines.append(header_1)\n pnl_lines.append(header_2)\n\n \"\"\"Clearly, there's a way to do this with only one pass of the data...\n let's get that right in the first re-write...probably with pandas\"\"\"\n\n #now let's fill up the pnl_lines with what we know to be the relevant data\n #for now, we'll rely on the knowledge that the data is coming to us in\n #date order, but that should be fixed too...\n\n for account in relevant_activity:\n\n account_row = [account, \"\"] #one value per period \n\n current_period_index = 0 #primitive counter, yes!\n this_period_total = 0 #this will be this period's total\n\n for line in relevant_activity[account]:\n \n line_amount = line[amount_i]\n line_date = line[date_i] \n\n if line_date > period_end_dates[current_period_index]:\n\n account_row.append(this_period_total)\n this_period_total = line_amount\n current_period_index +=1\n\n else:\n \n this_period_total = round(this_period_total +\n line_amount, 2)\n\n \"\"\"super sloppy...\"\"\"\n account_row.append(this_period_total) #for the last period\n current_period_index +=1\n\n while current_period_index < len(period_end_dates):\n account_row.append(0)\n current_period_index +=1\n\n pnl_lines.append(account_row)\n\n return pnl_lines","def periods(self) -> localedata.LocaleDataDict:\n try:\n return self._data['day_periods']['stand-alone']['wide']\n except KeyError:\n return localedata.LocaleDataDict({}) # pragma: no cover","def period_dates(period):\n end = date.today() - timedelta(days=1) # yesterday\n\n if period == LAST_7_DAYS:\n start = end - timedelta(days=7)\n elif period == LAST_30_DAYS:\n start = end - timedelta(days=30)\n elif period == LAST_90_DAYS:\n start = end - timedelta(days=90)\n elif ALL_TIME:\n start = settings.GA_START_DATE\n\n return start, end","def get_period(year, month):\n first_weekday, days = calendar.monthrange(year, month)\n first = datetime.date(year=year, month=month, day=1)\n last = datetime.date(year=year, month=month, day=days)\n return first, last","def getReportingPeriod(begin, end, week, month, year, last):\n if begin and end:\n rval = (datetime.strptime(begin, '%Y-%m-%d'),\n datetime.strptime(end, '%Y-%m-%d'))\n elif week or month or year:\n if last:\n rval = 'Last'\n else:\n rval = 'This'\n if week:\n rval += 'Week'\n elif month:\n rval += 'Month'\n else:\n rval += 'Year'\n else:\n rval = 'Yesterday'\n return rval","def test_is_active_active_not_between(self) -> None:\n today = date.today()\n start_date = today - timedelta(days=today.weekday() - 2)\n end_date = today - timedelta(days=today.weekday() - 1)\n mode = HolidayMode(True, start_date, end_date, 15)\n self.assertFalse(mode.is_applied)","def _getTimePeriod(self):\n if isinstance(self.period, tuple):\n period = self.soapCustomDateRange % \\\n (self.soapCustomDate % (self.period[1].day,\n self.period[1].month,\n self.period[1].year),\n self.soapCustomDate % (self.period[0].day,\n self.period[0].month,\n self.period[0].year))\n else:\n period = self.soapPredefinedTime % self.period\n self.logger.debug(\"period = %s\", period)\n return period","def availableWorkersDuringPeriod(self, begin, end):\n availableWorkers = []\n for worker in self._workers:\n if worker.availableInPeriod(begin, end):\n availableWorkers.append(worker)\n return availableWorkers","def amount_already_paid_in_period(self):\n assert self.type == \"N\", _(\"Subscription must be normal to use this method\")\n period_start, period_end = self.get_current_period()\n price_per_day = (\n self.get_price_for_full_period() / (period_end - period_start).days\n )\n days_already_used = (date.today() - period_start).days\n amount = int(price_per_day * days_already_used)\n if amount > self.get_price_for_full_period():\n amount = self.get_price_for_full_period()\n if amount < 0:\n amount = 0\n return amount","def get_time_period(value):\n\t\tfor time_period in TimePeriod:\n\t\t\tif time_period.period == value:\n\t\t\t\treturn time_period\n\t\traise ValueError('{} is not a valid TimePeriod'.format(value))","def two_factor_grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"two_factor_grace_period\")","def two_factor_grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"two_factor_grace_period\")","def valid_from(self) -> datetime:\n return self._valid_from","def grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"grace_period\")","def grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"grace_period\")","def grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"grace_period\")","def grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"grace_period\")","def limit_date_range_from(self):\n return self._limit_date_range_from"],"string":"[\n \"def getCurrentValidAccountingPeriod():\\n currentValidAccountingPeriod = None\\n for accountingPeriod in AccountingPeriod.objects.all():\\n if accountingPeriod.begin < date.today() and accountingPeriod.end > date.today():\\n return accountingPeriod\\n if currentValidAccountingPeriod == None:\\n raise NoFeasableAccountingPeriodFound()\",\n \"def get_current_period(self):\\n if not self.next_billing:\\n return None\\n assert self.type == \\\"N\\\", _(\\\"Subscription must be normal to use this method\\\")\\n start = self.next_billing - relativedelta(months=self.frequency)\\n end = self.next_billing\\n return start, end\",\n \"def current_period(self):\\n return self._current_period\",\n \"def get_all_prior_accounting_periods(target_accounting_period):\\n accounting_periods = []\\n for accounting_period in AccountingPeriod.objects.all():\\n if accounting_period.end < target_accounting_period.begin:\\n accounting_periods.append(accounting_period)\\n if accounting_periods == []:\\n raise AccountingPeriodNotFound(\\\"Accounting Period does not exist\\\")\\n return accounting_periods\",\n \"def getAllPriorAccountingPeriods(targetAccountingPeriod):\\n currentValidAccountingPeriod = None\\n accountingPeriods = []\\n for accountingPeriod in AccountingPeriod.objects.all():\\n if accountingPeriod.end < targetAccountingPeriod.begin:\\n accountingPeriods.append(accountingPeriod)\\n if accountingPeriods == []:\\n raise NoPriorAccountingPeriodFound()\\n return accountingPeriods\",\n \"def period(self):\\n return self.__period\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def __get_period(self):\\n return self.__period\",\n \"def get_chart_period(self,req):\\n now=int(DATE())\\n period=INT(req.period) # allow for it having been a string\\n if period>9999: # assume it is a month\\n if period<(now//100): # a valid complete previous month\\n prior=True# this is a previous month\\n else:\\n period=now//100 # default to current month\\n prior=False\\n start=period*100+1\\n end=self.nextperiod(period)*100+1\\n else: # assume it is a year\\n if period and (period<(now//10000)): # a prior year\\n prior=True# this is a previous year\\n else:\\n##\\n# period=now//100 # default to current month\\n# prior=False\\n# start=period*100+1\\n# end=self.nextperiod(period)*100+1\\n##\\n period=now//10000 # default to current year\\n prior=False\\n start=period*10000+101\\n end=self.nextperiod(period)*10000+101\\n return period,start,end,prior\",\n \"def planning_period(self):\\n return self._planning_period\",\n \"def getPeriod(self):\\n return StripePeriod(self.base.get(\\\"period\\\", []))\",\n \"def billing_period(self) -> Optional[str]:\\n return pulumi.get(self, \\\"billing_period\\\")\",\n \"def get_interval(self):\\n return self._period\",\n \"def get_period(self):\\n # res\\n if self._cacheExpiration <= YAPI.GetTickCount():\\n if self.load(YAPI._yapiContext.GetCacheValidity()) != YAPI.SUCCESS:\\n return YPwmOutput.PERIOD_INVALID\\n res = self._period\\n return res\",\n \"def get_period_guarantee_faithful_compliance(self):\\n return ceiling(self.get_period_faithful_compliance, 3)\",\n \"def remaining_days_in_current_period(self):\\n try:\\n return self.count_days_from_now(self.current_period_ends_at)\\n except AttributeError:\\n return 0\",\n \"def get_period_range(self, period, start, end, inclusive_start=True, inclusive_end=True):\\n if not isinstance(start, datetime.datetime):\\n start = self.get_date_from_string(start, '%Y-%m-%d')\\n if not isinstance(end, datetime.datetime):\\n end = self.get_date_from_string(end, '%Y-%m-%d')\\n\\n if period == 'month':\\n get_period = self.get_current_month_range\\n get_next_period = self.get_next_month\\n get_previous_period = self.get_previous_month\\n if period == 'week':\\n get_period = self.get_current_week_range\\n get_next_period = self.get_next_week\\n get_previous_period = self.get_previous_week\\n\\n #####################\\n # inclusive_start means that the result set will include the whole period\\n # containing the start date. Likewise for inclusive_end.\\n #\\n # If you are, say, reporting on a 'last completed month' or something,\\n # but your report date (and end date) is mid-month or something, then setting 'inclusive_end'\\n # to False will insure that the report ends with the month prior to the\\n # end date.\\n #\\n # If you're doing projections starting with the month following the one\\n # you're in, setting inclusive_start to False will insure that the first\\n # period in the range is the one *after* the period you're in now.\\n #######################\\n if not inclusive_start:\\n start = get_next_period(start)[0]\\n if not inclusive_end:\\n end = get_previous_period(end)[1]\\n\\n returnvals = []\\n\\n\\n firstper = get_period(start)\\n returnvals.append(firstper)\\n per = firstper\\n while per[1] < end:\\n # goes as long as the *end* of the period is < our end date.\\n # the intent is that if end is 2010-10-04, the last period will be\\n # (2010-10-01, 2010-10-31)\\n per = get_next_period(per[1])\\n returnvals.append(per)\\n\\n return returnvals\",\n \"def checkpoint_period_get(self):\\n raise Exception(\\\"TODO\\\")\",\n \"def expected_last_period_end(self):\\n return self._expected_last_period_end\",\n \"def valid_period(request):\\n return request.param\",\n \"def _get_period(self, cr, uid, context={}):\\n\\n account_period_obj = self.pool.get('account.period')\\n ids = account_period_obj.find(\\n cr, uid, time.strftime('%Y-%m-%d'), context=context)\\n period_id = ids[0]\\n return period_id\",\n \"def real_period(self):\\n return max(\\n self.period * self.PERIOD_MARGIN_FACTOR -\\n (self.max_lag if self.max_lag else self.lag * self.LAG_MARGIN_FACTOR),\\n 0.0)\",\n \"def getBeginEnd(self):\\n if (self.dr_type == choices.DATE_RANGE_TYPE_FIXED):\\n return self.begin, self.end\\n\\n elif (self.dr_type == choices.DATE_RANGE_TYPE_VARIABLE):\\n end = datetime.now()\\n\\n if (self.unit == choices.TIME_UNIT_DAY):\\n begin = end - relativedelta(days=self.quantity)\\n\\n elif (self.unit == choices.TIME_UNIT_WEEK):\\n begin = end - relativedelta(weeks=self.quantity)\\n\\n elif (self.unit == choices.TIME_UNIT_MONTH):\\n begin = end - relativedelta(months=self.quantity)\\n\\n elif (self.unit == choices.TIME_UNIT_YEAR):\\n begin = end - relativedelta(years=self.quantity)\\n\\n else:\\n # This case should not happen\\n raise Exception(\\\"A DateRange object's 'unit' must be a numeric\\\"\\n \\\" value in: {units}.\\\".format(units=\\\", \\\".join([\\n \\\"{const} ({name})\\\".format(const=unit, name=unit_name)\\n for unit, unit_name in choices.TIME_UNIT\\n if unit is not None]))\\n )\\n\\n return begin, end\\n\\n else:\\n # This case should not happen\\n raise Exception(\\\"A DateRange object's 'dr_type' must be one of:\\\"\\n \\\" {const_fixed} (fixed range) or {const_dynamic}\\\"\\n \\\" (dynamic range).\\\".format(\\n const_fixed=choices.DATE_RANGE_TYPE_FIXED,\\n const_dynamic=choices.DATE_RANGE_TYPE_VARIABLE\\n ))\",\n \"def period(self) -> int:\",\n \"def get_period_guarantee_advance(self):\\n return ceiling(self.scheduled_completion, 3)\",\n \"def renewal_period(self) -> Optional[float]:\\n return pulumi.get(self, \\\"renewal_period\\\")\",\n \"def get_first_period(start_record, end_record, start_period, end_period):\\n start_record, end_record, start_period, end_period = to_datetime(start_record, end_record, start_period, end_period)\\n pspan = end_period - start_period\\n delta_year = relativedelta(years=1)\\n # what is the first day of year of the start of the period that fits the record?\\n start_rec_year = start_record.year\\n d = datetime(start_rec_year, start_period.month, start_period.day)\\n if d < start_record:\\n d = d + delta_year\\n delta_years = start_period.year - d.year\\n e = end_period + relativedelta(years=-delta_years)\\n return (d, e)\",\n \"def periodCheck(data):\",\n \"def date_validity(self):\\n return self._date_validity\",\n \"def _get_period(self, cr, uid, context=None):\\n context = context or {}\\n if context.get('period_id', False):\\n return context['period_id']\\n account_period_obj = self.pool.get('account.period')\\n ctx = dict(context, account_period_prefer_normal=True)\\n ids = account_period_obj.find(cr, uid, context=ctx)\\n period_id = False\\n if ids:\\n period_id = ids[0]\\n return period_id\",\n \"def between(cls, begin_date: datetime.date, end_date: datetime.date) -> float:\\n\\n if begin_date > end_date:\\n raise ValueError('End date must not be before begin date.')\\n if begin_date == end_date:\\n return 0\\n data = cls.cumulative()\\n first = data.get((begin_date.year, begin_date.month), None)\\n last = data.get((end_date.year, end_date.month), None)\\n if first is None or last is None:\\n raise ValidationError(\\\"Inflation figures don't cover entire period requested: {} - {}\\\".format(begin_date,\\n end_date))\\n return (last / first) - 1\",\n \"def orbital_period(self):\\n return self._orbital_period\",\n \"def valid_until(self) -> datetime:\\n return self._valid_until\",\n \"def current(self) -> Optional['outputs.CommitmentPeriodResponse']:\\n return pulumi.get(self, \\\"current\\\")\",\n \"def _period_from_date(self):\\n if self.date['year']:\\n if self.date['month']:\\n if self.date['day']:\\n self.period = Period.DAILY\\n else:\\n self.period = Period.MONTHLY\\n else:\\n self.period = Period.YEARLY\\n else:\\n self.period = Period.FULL\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def test_list_grading_periods_accounts(self):\\r\\n account_id = None # Change me!!\\r\\n\\r\\n r = self.client.list_grading_periods_accounts(account_id)\",\n \"def get_period_budgets(cls, now):\\n limits_dict = {}\\n strategies = cls.objects_visible.filter(is_distributed_evenly=True)\\n strategies = cls.running(strategies)\\n\\n for strategy in strategies:\\n limits_dict[strategy.public_id] = strategy.period_budget(now)\\n\\n log.info('[SPENDINGS] Period budgets calculated (currency): {0}'.format(limits_dict))\\n\\n # Cast to budget precision used in Redis\\n return {strategy: cast_CPM_to_dbbid(cast_currency_to_CPM(budget)) for strategy, budget in limits_dict.items()}\",\n \"def billing_period_start(self): # ISO8601 or timestamp\\n return self._safe_value(VAR_BILLINGPERIODSTART, int)\",\n \"def amount_to_pay_in_period(self):\\n assert self.type == \\\"N\\\", _(\\\"Subscription must be normal to use this method\\\")\\n period_start, period_end = self.get_current_period()\\n price_per_day = (\\n self.get_price_for_full_period() / (period_end - period_start).days\\n )\\n days_not_used = 30 * self.frequency - (date.today() - period_start).days\\n return int(price_per_day * days_not_used)\",\n \"def current_effective_deadline(cls) -> float:\",\n \"def get_periods():\\n return [\\n relativedelta(),\\n relativedelta(days=6),\\n relativedelta(months=1),\\n relativedelta(months=3),\\n relativedelta(years=1),\\n relativedelta(years=5)\\n ]\",\n \"def get_period(self):\\n raise NotImplementedError('Agent is an abstract base class')\",\n \"def block_period_consumption(self):\\n return self._safe_value(VAR_BLOCKPERIODCONSUMPTION, float)\",\n \"def get_last_period(self, status_id, company_payroll_id, config=None):\\n if not config:\\n config = self.env['ka_hr_payroll.config'].default_config()\\n\\n date_now = datetime.now().date()\\n date_config = datetime.strptime(\\\"{0}-{1}-{2}\\\".format(date_now.year, date_now.month, config.date_start),\\n DATE_FORMAT)\\n date_config_str = date_config.strftime(DATE_FORMAT)\\n\\n return self.search([\\n ('date_start', '<=', fields.Date.today()),\\n ('status_id', 'parent_of', status_id),\\n ('state', '=', 'done'),\\n ('state_rapel', '!=', '1'),\\n ('date_done', '<', date_config_str),\\n ('company_payroll_id', '=', company_payroll_id)\\n ], limit=1, order='date_start desc')\",\n \"def remaining_days(self):\\n if self.trialing or self.trial_ended:\\n return self.remaining_trial_days\\n else:\\n return self.remaining_days_in_current_period\",\n \"def period(self):\\n return float(self._period) / 1000\",\n \"def sleepPeriodValidate(self):\\n # sleep_validate = False (not in sleep period)\\n # sleep_validate = True (in sleep period)\\n \\n sleep_validate = None\\n pre_midnight = '23:59'\\n midnight = '00:00'\\n \\n # check if out of sleep period\\n if self.current_time >= self.sleep_stop and self.current_time < self.sleep_start:\\n sleep_validate = False\\n \\n # check if in sleep period\\n elif self.current_time >= self.sleep_start and self.current_time <= pre_midnight:\\n sleep_validate = True \\n elif self.current_time < self.sleep_stop and self.current_time > midnight:\\n sleep_validate = True\\n \\n return sleep_validate\",\n \"def getUpdatePeriod( self, obj=None ):\\n if obj is not None:\\n period = self.getSyndicationInfo(obj).period\\n else:\\n period = self.period\\n return period\",\n \"def kind(self):\\n return DateValueTypes.PERIOD\",\n \"def get_current_fiscal_year(self):\\n current_date = datetime.today().date()\\n for year in self.fiscal_years.all():\\n if year.begin_date < current_date < year.end_date:\\n return year\\n return None\",\n \"def dispatch_interval(self):\\n start = self.start\\n start_date = start.date()\\n\\n # add zero padding to make period_id 3 chars long\\n period_id = str(self.period_id).zfill(3)\\n\\n if start.hour < 4 and period_id != \\\"001\\\":\\n start_date = start_date - timedelta(days=1)\\n\\n # Concat zero-padded dates and add period id\\n dispatch_interval = \\\"\\\".join([start_date.strftime(\\\"%Y%m%d\\\"), period_id])\\n\\n return dispatch_interval\",\n \"def InactiveNoEndDate(obj):\\n if not obj.active_p:\\n if not (obj.end_date):\\n raise interface.Invalid(\\n _(\\\"If a person is inactive End Date must be set\\\"), \\n \\\"end_date\\\", \\n \\\"active_p\\\")\",\n \"def in_grace_period_count(self):\\n if \\\"inGracePeriodCount\\\" in self._prop_dict:\\n return self._prop_dict[\\\"inGracePeriodCount\\\"]\\n else:\\n return None\",\n \"def get_employees_born_in_period(cls, start_date, end_date,\\n strategy=lazyload):\\n cls._check_strategy(strategy)\\n\\n employees = db.session.query(Employee).options(\\n strategy(Employee.department)\\n ).filter(\\n and_(\\n Employee.date_of_birth > start_date,\\n Employee.date_of_birth < end_date\\n )\\n ).all()\\n return employees\",\n \"def _get_default_period(self, cr, uid, context=None):\\n context = context or {}\\n if context.get('period_id', False):\\n return context['period_id']\\n account_period_obj = self.pool.get('account.period')\\n ctx = dict(context, account_period_prefer_normal=True)\\n ids = account_period_obj.find(cr, uid, context=ctx)\\n period_id = False\\n if ids:\\n period_id = ids[0]\\n return period_id\",\n \"def validate_check_in_period(check_in_period):\\n if not check_in_period:\\n check_in_period = 30\\n if not isinstance(check_in_period, int):\\n try:\\n check_in_period = int(check_in_period)\\n except ValueError:\\n print \\\"Incorrect check-in period given. Setting to 30.\\\"\\n check_in_period = 30\\n\\n return check_in_period\",\n \"def find_period_below(self, start, end, target, length):\\n\\n if start > end:\\n raise ValueError(\\\"End needs to be after start!\\\")\\n if length < 0:\\n raise ValueError(\\\"Period length must be larger than zero!\\\")\\n\\n period_start = (start if self.get(start) <= target else None)\\n\\n start_ix = self._trace.bisect_right(start)\\n end_ix = self._trace.bisect_left(end)\\n for time, lvl in self._trace.items()[start_ix:end_ix]:\\n # Period long enough?\\n if period_start is not None:\\n if time >= period_start + length:\\n return period_start\\n # Not enough space until end?\\n elif time + length > end:\\n return None\\n # Above target? Reset period\\n if lvl > target:\\n period_start = None\\n else:\\n if period_start is None:\\n period_start = time\\n\\n # Possible at end?\\n if period_start is not None and period_start+length <= end:\\n return period_start\\n\\n # Nothing found\\n return None\",\n \"def valid_until(self):\\n return self._valid_until / 10000000\",\n \"def get_period(self, df, key):\\n daysFiltered = self.filter_days(df, **self.periods[key]['days'])\\n perStart = string_date(self.periods[key]['dates'][0], df.index[0].date().year)\\n perEnd = string_date(self.periods[key]['dates'][1], df.index[0].date().year)\\n if self.spans_year(key):\\n # slice period for beginning of the year\\n fall = daysFiltered.ix[perStart:string_date('12/31', df.index[0].date().year)]\\n fall = fall.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\\n fall = fall.sort_index()\\n # slice period for end of the year\\n spring = fall.append(daysFiltered.ix[string_date('1/1', df.index[0].date().year):perEnd])\\n spring = spring.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\\n spring = spring.sort_index()\\n return(spring.rename_axis({'data': key}, axis=1))\\n else:\\n df_temp = daysFiltered.ix[perStart:perEnd]\\n df_temp = df_temp.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\\n return(df_temp.rename_axis({'data': key}, axis=1))\",\n \"def get_debt_state(member, limit_year, limit_month):\\n if member.first_payment_year is None:\\n # never paid! using registration date to start with\\n yearmonths_paid = set()\\n year_to_check = member.registration_date.year\\n month_to_check = member.registration_date.month\\n else:\\n # build a set for the year/month of paid quotas\\n quotas = Quota.objects.filter(member=member).all()\\n yearmonths_paid = {(q.year, q.month) for q in quotas}\\n\\n year_to_check = member.first_payment_year\\n month_to_check = member.first_payment_month\\n\\n # verify the limit is after member started paying\\n if year_to_check == limit_year:\\n if month_to_check > limit_month:\\n return []\\n elif year_to_check > limit_year:\\n return []\\n\\n # build a set of all the year/month the member should have paid up to (including) the limit\\n should_have_paid = set()\\n while True:\\n should_have_paid.add((year_to_check, month_to_check))\\n year_to_check, month_to_check = increment_year_month(year_to_check, month_to_check)\\n if year_to_check == limit_year:\\n if month_to_check > limit_month:\\n break\\n elif year_to_check > limit_year:\\n break\\n\\n return sorted(should_have_paid - yearmonths_paid)\",\n \"def period_check(init_dates, fcst_dates):\\n check_dates(init_dates)\\n check_dates(fcst_dates)\\n \\n if max(init_dates) > min(fcst_dates):\\n raise ValueError('Forecast date, %s comes before initialisation '\\\\\\n 'date, %s.' % (min(fcst_dates), max(init_dates)))\\n\\n fcst_dates = change_zeroth_hour(fcst_dates)\\n return init_dates, fcst_dates\",\n \"def period(self):\\n return f\\\"{self.measurement_date.year}/{self.measurement_date.month}\\\"\",\n \"def determine_periods(obj):\\n return obj[len(obj)-1][\\\"period\\\"]\",\n \"def pnl(qbo_session, period = \\\"YEARLY\\\", start_date=\\\"first\\\", end_date=\\\"last\\\",\\n **kwargs):\\n\\n pnl_account_types = [\\n \\n \\\"Income\\\", \\\"Other Income\\\",\\n \\\"Expense\\\", \\\"Other Expense\\\", \\\"Cost of Goods Sold\\\"\\n \\n ]\\n\\n \\n\\n # go through the accounts, collecting a list of those that are \\n # pnl accounts\\n\\n relevant_accounts = []\\n\\n coa = qbo_session.chart_of_accounts()\\n\\n AccountType_i = coa[0].index(\\\"AccountType\\\")\\n fqa_i = coa[0].index(\\\"FullyQualifiedName\\\")\\n\\n for a in coa:\\n\\n AccountType = a[AccountType_i]\\n\\n if AccountType in pnl_account_types:\\n\\n relevant_accounts.append(a[fqa_i])\\n \\n # now collect the ledger_lines that are even relevant to the time\\n # period and pnl accounts (and we'll handle presentation last)\\n\\n relevant_activity = {} #{account:[relevant lines]}\\n\\n all_ledger_lines = qbo_session.ledger_lines(None, None, None, True,\\n **kwargs)\\n\\n headers = all_ledger_lines[0]\\n\\n account_i = headers.index(\\\"account\\\") \\n amount_i = headers.index(\\\"amount\\\")\\n date_i = headers.index(\\\"TxnDate\\\")\\n \\n earliest_date = datetime(2100,1,1)\\n latest_date = datetime(1900,1,1)\\n\\n for line in all_ledger_lines[1:]:\\n\\n account = line[account_i]\\n line_date = line[date_i]\\n\\n #first apply the date filter!\\n if not start_date == \\\"first\\\" and line_date < start_date:\\n continue\\n \\n if not end_date == \\\"last\\\" and line_date > end_date:\\n continue\\n \\n #if it's made the cut, we can update the report date bounds\\n earliest_date = min(line_date,earliest_date)\\n latest_date = max(line_date,latest_date)\\n\\n #then apply the account filter!\\n\\n if not account in relevant_activity:\\n #then let's confirm that its account type is a pnl one\\n \\n if not account in relevant_accounts:\\n \\n continue\\n\\n else:\\n relevant_activity[account] = []\\n\\n relevant_activity[account].append(line)\\n\\n #now let's do presentation\\n #TODO -- incorporate pandas tables...do only minimal work on it until then\\n\\n pnl_lines = []\\n\\n if period == \\\"YEARLY\\\":\\n\\n report_start_date = datetime(earliest_date.year,1,1)\\n report_end_date = datetime(latest_date.year,12,31)\\n\\n period_start_dates = list(rrule(YEARLY, bymonth=1, bymonthday=1,\\n dtstart=report_start_date,\\n until=report_end_date))\\n\\n period_end_dates = list(rrule(YEARLY, bymonth=12, bymonthday=-1,\\n dtstart=report_start_date,\\n until=report_end_date))\\n\\n elif period == \\\"MONTHLY\\\":\\n\\n report_start_date = datetime(earliest_date.year,\\n earliest_date.month,\\n 1)\\n report_end_date = datetime(latest_date.year,\\n latest_date.month,\\n calendar.monthrange(latest_date.year,\\n latest_date.month)[1])\\n\\n period_start_dates = list(rrule(MONTHLY, bymonthday=1,\\n dtstart=report_start_date,\\n until=report_end_date))\\n\\n period_end_dates = list(rrule(YEARLY, bymonthday=-1,\\n dtstart=report_start_date,\\n until=report_end_date)) \\n\\n header_1 = [\\\"\\\", \\\"Period Start -->\\\"] + period_start_dates\\n header_2 = [\\\"Account\\\", \\\"Period End -->\\\"] + period_end_dates\\n\\n pnl_lines.append(header_1)\\n pnl_lines.append(header_2)\\n\\n \\\"\\\"\\\"Clearly, there's a way to do this with only one pass of the data...\\n let's get that right in the first re-write...probably with pandas\\\"\\\"\\\"\\n\\n #now let's fill up the pnl_lines with what we know to be the relevant data\\n #for now, we'll rely on the knowledge that the data is coming to us in\\n #date order, but that should be fixed too...\\n\\n for account in relevant_activity:\\n\\n account_row = [account, \\\"\\\"] #one value per period \\n\\n current_period_index = 0 #primitive counter, yes!\\n this_period_total = 0 #this will be this period's total\\n\\n for line in relevant_activity[account]:\\n \\n line_amount = line[amount_i]\\n line_date = line[date_i] \\n\\n if line_date > period_end_dates[current_period_index]:\\n\\n account_row.append(this_period_total)\\n this_period_total = line_amount\\n current_period_index +=1\\n\\n else:\\n \\n this_period_total = round(this_period_total +\\n line_amount, 2)\\n\\n \\\"\\\"\\\"super sloppy...\\\"\\\"\\\"\\n account_row.append(this_period_total) #for the last period\\n current_period_index +=1\\n\\n while current_period_index < len(period_end_dates):\\n account_row.append(0)\\n current_period_index +=1\\n\\n pnl_lines.append(account_row)\\n\\n return pnl_lines\",\n \"def periods(self) -> localedata.LocaleDataDict:\\n try:\\n return self._data['day_periods']['stand-alone']['wide']\\n except KeyError:\\n return localedata.LocaleDataDict({}) # pragma: no cover\",\n \"def period_dates(period):\\n end = date.today() - timedelta(days=1) # yesterday\\n\\n if period == LAST_7_DAYS:\\n start = end - timedelta(days=7)\\n elif period == LAST_30_DAYS:\\n start = end - timedelta(days=30)\\n elif period == LAST_90_DAYS:\\n start = end - timedelta(days=90)\\n elif ALL_TIME:\\n start = settings.GA_START_DATE\\n\\n return start, end\",\n \"def get_period(year, month):\\n first_weekday, days = calendar.monthrange(year, month)\\n first = datetime.date(year=year, month=month, day=1)\\n last = datetime.date(year=year, month=month, day=days)\\n return first, last\",\n \"def getReportingPeriod(begin, end, week, month, year, last):\\n if begin and end:\\n rval = (datetime.strptime(begin, '%Y-%m-%d'),\\n datetime.strptime(end, '%Y-%m-%d'))\\n elif week or month or year:\\n if last:\\n rval = 'Last'\\n else:\\n rval = 'This'\\n if week:\\n rval += 'Week'\\n elif month:\\n rval += 'Month'\\n else:\\n rval += 'Year'\\n else:\\n rval = 'Yesterday'\\n return rval\",\n \"def test_is_active_active_not_between(self) -> None:\\n today = date.today()\\n start_date = today - timedelta(days=today.weekday() - 2)\\n end_date = today - timedelta(days=today.weekday() - 1)\\n mode = HolidayMode(True, start_date, end_date, 15)\\n self.assertFalse(mode.is_applied)\",\n \"def _getTimePeriod(self):\\n if isinstance(self.period, tuple):\\n period = self.soapCustomDateRange % \\\\\\n (self.soapCustomDate % (self.period[1].day,\\n self.period[1].month,\\n self.period[1].year),\\n self.soapCustomDate % (self.period[0].day,\\n self.period[0].month,\\n self.period[0].year))\\n else:\\n period = self.soapPredefinedTime % self.period\\n self.logger.debug(\\\"period = %s\\\", period)\\n return period\",\n \"def availableWorkersDuringPeriod(self, begin, end):\\n availableWorkers = []\\n for worker in self._workers:\\n if worker.availableInPeriod(begin, end):\\n availableWorkers.append(worker)\\n return availableWorkers\",\n \"def amount_already_paid_in_period(self):\\n assert self.type == \\\"N\\\", _(\\\"Subscription must be normal to use this method\\\")\\n period_start, period_end = self.get_current_period()\\n price_per_day = (\\n self.get_price_for_full_period() / (period_end - period_start).days\\n )\\n days_already_used = (date.today() - period_start).days\\n amount = int(price_per_day * days_already_used)\\n if amount > self.get_price_for_full_period():\\n amount = self.get_price_for_full_period()\\n if amount < 0:\\n amount = 0\\n return amount\",\n \"def get_time_period(value):\\n\\t\\tfor time_period in TimePeriod:\\n\\t\\t\\tif time_period.period == value:\\n\\t\\t\\t\\treturn time_period\\n\\t\\traise ValueError('{} is not a valid TimePeriod'.format(value))\",\n \"def two_factor_grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"two_factor_grace_period\\\")\",\n \"def two_factor_grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"two_factor_grace_period\\\")\",\n \"def valid_from(self) -> datetime:\\n return self._valid_from\",\n \"def grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"grace_period\\\")\",\n \"def grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"grace_period\\\")\",\n \"def grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"grace_period\\\")\",\n \"def grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"grace_period\\\")\",\n \"def limit_date_range_from(self):\\n return self._limit_date_range_from\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82862264","0.6872075","0.65232825","0.6370569","0.6290718","0.60823673","0.6040515","0.6040515","0.6040515","0.6040515","0.6040515","0.6040515","0.6040515","0.6040515","0.6018042","0.6012301","0.5940794","0.59097856","0.5859212","0.5821298","0.5755713","0.57361776","0.57259804","0.5627092","0.5623561","0.56206757","0.5603892","0.55797243","0.557284","0.551847","0.5513599","0.54543895","0.5438986","0.5431954","0.542451","0.5408851","0.5408489","0.5381044","0.5378068","0.5363383","0.5348973","0.53457713","0.5343646","0.5343646","0.5343646","0.5343646","0.5343646","0.5343646","0.5343646","0.5343646","0.5343646","0.5343646","0.5343646","0.5343646","0.5300969","0.5296546","0.5283699","0.5280615","0.5269267","0.52642983","0.523902","0.52314234","0.522582","0.5215747","0.5184535","0.5178225","0.5167521","0.5165441","0.5136053","0.510341","0.5097612","0.50848705","0.5083586","0.50773853","0.50672716","0.5067223","0.5059559","0.50570977","0.5055609","0.5054063","0.5043461","0.50415504","0.5023548","0.50187474","0.5013629","0.5009764","0.50083405","0.4998141","0.4996523","0.49894312","0.4981192","0.49754077","0.49590197","0.49590197","0.49558988","0.49378783","0.49378783","0.49378783","0.49378783","0.49354696"],"string":"[\n \"0.82862264\",\n \"0.6872075\",\n \"0.65232825\",\n \"0.6370569\",\n \"0.6290718\",\n \"0.60823673\",\n \"0.6040515\",\n \"0.6040515\",\n \"0.6040515\",\n \"0.6040515\",\n \"0.6040515\",\n \"0.6040515\",\n \"0.6040515\",\n \"0.6040515\",\n \"0.6018042\",\n \"0.6012301\",\n \"0.5940794\",\n \"0.59097856\",\n \"0.5859212\",\n \"0.5821298\",\n \"0.5755713\",\n \"0.57361776\",\n \"0.57259804\",\n \"0.5627092\",\n \"0.5623561\",\n \"0.56206757\",\n \"0.5603892\",\n \"0.55797243\",\n \"0.557284\",\n \"0.551847\",\n \"0.5513599\",\n \"0.54543895\",\n \"0.5438986\",\n \"0.5431954\",\n \"0.542451\",\n \"0.5408851\",\n \"0.5408489\",\n \"0.5381044\",\n \"0.5378068\",\n \"0.5363383\",\n \"0.5348973\",\n \"0.53457713\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5343646\",\n \"0.5300969\",\n \"0.5296546\",\n \"0.5283699\",\n \"0.5280615\",\n \"0.5269267\",\n \"0.52642983\",\n \"0.523902\",\n \"0.52314234\",\n \"0.522582\",\n \"0.5215747\",\n \"0.5184535\",\n \"0.5178225\",\n \"0.5167521\",\n \"0.5165441\",\n \"0.5136053\",\n \"0.510341\",\n \"0.5097612\",\n \"0.50848705\",\n \"0.5083586\",\n \"0.50773853\",\n \"0.50672716\",\n \"0.5067223\",\n \"0.5059559\",\n \"0.50570977\",\n \"0.5055609\",\n \"0.5054063\",\n \"0.5043461\",\n \"0.50415504\",\n \"0.5023548\",\n \"0.50187474\",\n \"0.5013629\",\n \"0.5009764\",\n \"0.50083405\",\n \"0.4998141\",\n \"0.4996523\",\n \"0.49894312\",\n \"0.4981192\",\n \"0.49754077\",\n \"0.49590197\",\n \"0.49590197\",\n \"0.49558988\",\n \"0.49378783\",\n \"0.49378783\",\n \"0.49378783\",\n \"0.49378783\",\n \"0.49354696\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8423247"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3198,"cells":{"query":{"kind":"string","value":"Returns the accounting period that is currently valid. Valid is an accountingPeriod when the current date lies between begin and end of the accountingPeriod"},"document":{"kind":"string","value":"def get_all_prior_accounting_periods(target_accounting_period):\n accounting_periods = []\n for accounting_period in AccountingPeriod.objects.all():\n if accounting_period.end < target_accounting_period.begin:\n accounting_periods.append(accounting_period)\n if accounting_periods == []:\n raise AccountingPeriodNotFound(\"Accounting Period does not exist\")\n return accounting_periods"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_current_valid_accounting_period():\n current_valid_accounting_period = None\n for accounting_period in AccountingPeriod.objects.all():\n if accounting_period.begin < date.today() and accounting_period.end > date.today():\n return accounting_period\n if not current_valid_accounting_period:\n raise AccountingPeriodNotFound()","def getCurrentValidAccountingPeriod():\n currentValidAccountingPeriod = None\n for accountingPeriod in AccountingPeriod.objects.all():\n if accountingPeriod.begin < date.today() and accountingPeriod.end > date.today():\n return accountingPeriod\n if currentValidAccountingPeriod == None:\n raise NoFeasableAccountingPeriodFound()","def get_current_period(self):\n if not self.next_billing:\n return None\n assert self.type == \"N\", _(\"Subscription must be normal to use this method\")\n start = self.next_billing - relativedelta(months=self.frequency)\n end = self.next_billing\n return start, end","def current_period(self):\n return self._current_period","def getAllPriorAccountingPeriods(targetAccountingPeriod):\n currentValidAccountingPeriod = None\n accountingPeriods = []\n for accountingPeriod in AccountingPeriod.objects.all():\n if accountingPeriod.end < targetAccountingPeriod.begin:\n accountingPeriods.append(accountingPeriod)\n if accountingPeriods == []:\n raise NoPriorAccountingPeriodFound()\n return accountingPeriods","def period(self):\n return self.__period","def getPeriod(self):\n return StripePeriod(self.base.get(\"period\", []))","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"period\")","def __get_period(self):\n return self.__period","def planning_period(self):\n return self._planning_period","def get_chart_period(self,req):\n now=int(DATE())\n period=INT(req.period) # allow for it having been a string\n if period>9999: # assume it is a month\n if period<(now//100): # a valid complete previous month\n prior=True# this is a previous month\n else:\n period=now//100 # default to current month\n prior=False\n start=period*100+1\n end=self.nextperiod(period)*100+1\n else: # assume it is a year\n if period and (period<(now//10000)): # a prior year\n prior=True# this is a previous year\n else:\n##\n# period=now//100 # default to current month\n# prior=False\n# start=period*100+1\n# end=self.nextperiod(period)*100+1\n##\n period=now//10000 # default to current year\n prior=False\n start=period*10000+101\n end=self.nextperiod(period)*10000+101\n return period,start,end,prior","def billing_period(self) -> Optional[str]:\n return pulumi.get(self, \"billing_period\")","def get_interval(self):\n return self._period","def get_period(self):\n # res\n if self._cacheExpiration <= YAPI.GetTickCount():\n if self.load(YAPI._yapiContext.GetCacheValidity()) != YAPI.SUCCESS:\n return YPwmOutput.PERIOD_INVALID\n res = self._period\n return res","def get_period_range(self, period, start, end, inclusive_start=True, inclusive_end=True):\n if not isinstance(start, datetime.datetime):\n start = self.get_date_from_string(start, '%Y-%m-%d')\n if not isinstance(end, datetime.datetime):\n end = self.get_date_from_string(end, '%Y-%m-%d')\n\n if period == 'month':\n get_period = self.get_current_month_range\n get_next_period = self.get_next_month\n get_previous_period = self.get_previous_month\n if period == 'week':\n get_period = self.get_current_week_range\n get_next_period = self.get_next_week\n get_previous_period = self.get_previous_week\n\n #####################\n # inclusive_start means that the result set will include the whole period\n # containing the start date. Likewise for inclusive_end.\n #\n # If you are, say, reporting on a 'last completed month' or something,\n # but your report date (and end date) is mid-month or something, then setting 'inclusive_end'\n # to False will insure that the report ends with the month prior to the\n # end date.\n #\n # If you're doing projections starting with the month following the one\n # you're in, setting inclusive_start to False will insure that the first\n # period in the range is the one *after* the period you're in now.\n #######################\n if not inclusive_start:\n start = get_next_period(start)[0]\n if not inclusive_end:\n end = get_previous_period(end)[1]\n\n returnvals = []\n\n\n firstper = get_period(start)\n returnvals.append(firstper)\n per = firstper\n while per[1] < end:\n # goes as long as the *end* of the period is < our end date.\n # the intent is that if end is 2010-10-04, the last period will be\n # (2010-10-01, 2010-10-31)\n per = get_next_period(per[1])\n returnvals.append(per)\n\n return returnvals","def get_period_guarantee_faithful_compliance(self):\n return ceiling(self.get_period_faithful_compliance, 3)","def remaining_days_in_current_period(self):\n try:\n return self.count_days_from_now(self.current_period_ends_at)\n except AttributeError:\n return 0","def expected_last_period_end(self):\n return self._expected_last_period_end","def getBeginEnd(self):\n if (self.dr_type == choices.DATE_RANGE_TYPE_FIXED):\n return self.begin, self.end\n\n elif (self.dr_type == choices.DATE_RANGE_TYPE_VARIABLE):\n end = datetime.now()\n\n if (self.unit == choices.TIME_UNIT_DAY):\n begin = end - relativedelta(days=self.quantity)\n\n elif (self.unit == choices.TIME_UNIT_WEEK):\n begin = end - relativedelta(weeks=self.quantity)\n\n elif (self.unit == choices.TIME_UNIT_MONTH):\n begin = end - relativedelta(months=self.quantity)\n\n elif (self.unit == choices.TIME_UNIT_YEAR):\n begin = end - relativedelta(years=self.quantity)\n\n else:\n # This case should not happen\n raise Exception(\"A DateRange object's 'unit' must be a numeric\"\n \" value in: {units}.\".format(units=\", \".join([\n \"{const} ({name})\".format(const=unit, name=unit_name)\n for unit, unit_name in choices.TIME_UNIT\n if unit is not None]))\n )\n\n return begin, end\n\n else:\n # This case should not happen\n raise Exception(\"A DateRange object's 'dr_type' must be one of:\"\n \" {const_fixed} (fixed range) or {const_dynamic}\"\n \" (dynamic range).\".format(\n const_fixed=choices.DATE_RANGE_TYPE_FIXED,\n const_dynamic=choices.DATE_RANGE_TYPE_VARIABLE\n ))","def _get_period(self, cr, uid, context={}):\n\n account_period_obj = self.pool.get('account.period')\n ids = account_period_obj.find(\n cr, uid, time.strftime('%Y-%m-%d'), context=context)\n period_id = ids[0]\n return period_id","def real_period(self):\n return max(\n self.period * self.PERIOD_MARGIN_FACTOR -\n (self.max_lag if self.max_lag else self.lag * self.LAG_MARGIN_FACTOR),\n 0.0)","def checkpoint_period_get(self):\n raise Exception(\"TODO\")","def current(self) -> Optional['outputs.CommitmentPeriodResponse']:\n return pulumi.get(self, \"current\")","def renewal_period(self) -> Optional[float]:\n return pulumi.get(self, \"renewal_period\")","def valid_period(request):\n return request.param","def valid_until(self) -> datetime:\n return self._valid_until","def date_validity(self):\n return self._date_validity","def period(self) -> int:","def get_first_period(start_record, end_record, start_period, end_period):\n start_record, end_record, start_period, end_period = to_datetime(start_record, end_record, start_period, end_period)\n pspan = end_period - start_period\n delta_year = relativedelta(years=1)\n # what is the first day of year of the start of the period that fits the record?\n start_rec_year = start_record.year\n d = datetime(start_rec_year, start_period.month, start_period.day)\n if d < start_record:\n d = d + delta_year\n delta_years = start_period.year - d.year\n e = end_period + relativedelta(years=-delta_years)\n return (d, e)","def orbital_period(self):\n return self._orbital_period","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"evaluation_periods\")","def get_period_guarantee_advance(self):\n return ceiling(self.scheduled_completion, 3)","def _get_period(self, cr, uid, context=None):\n context = context or {}\n if context.get('period_id', False):\n return context['period_id']\n account_period_obj = self.pool.get('account.period')\n ctx = dict(context, account_period_prefer_normal=True)\n ids = account_period_obj.find(cr, uid, context=ctx)\n period_id = False\n if ids:\n period_id = ids[0]\n return period_id","def sleepPeriodValidate(self):\n # sleep_validate = False (not in sleep period)\n # sleep_validate = True (in sleep period)\n \n sleep_validate = None\n pre_midnight = '23:59'\n midnight = '00:00'\n \n # check if out of sleep period\n if self.current_time >= self.sleep_stop and self.current_time < self.sleep_start:\n sleep_validate = False\n \n # check if in sleep period\n elif self.current_time >= self.sleep_start and self.current_time <= pre_midnight:\n sleep_validate = True \n elif self.current_time < self.sleep_stop and self.current_time > midnight:\n sleep_validate = True\n \n return sleep_validate","def get_period_budgets(cls, now):\n limits_dict = {}\n strategies = cls.objects_visible.filter(is_distributed_evenly=True)\n strategies = cls.running(strategies)\n\n for strategy in strategies:\n limits_dict[strategy.public_id] = strategy.period_budget(now)\n\n log.info('[SPENDINGS] Period budgets calculated (currency): {0}'.format(limits_dict))\n\n # Cast to budget precision used in Redis\n return {strategy: cast_CPM_to_dbbid(cast_currency_to_CPM(budget)) for strategy, budget in limits_dict.items()}","def getUpdatePeriod( self, obj=None ):\n if obj is not None:\n period = self.getSyndicationInfo(obj).period\n else:\n period = self.period\n return period","def amount_to_pay_in_period(self):\n assert self.type == \"N\", _(\"Subscription must be normal to use this method\")\n period_start, period_end = self.get_current_period()\n price_per_day = (\n self.get_price_for_full_period() / (period_end - period_start).days\n )\n days_not_used = 30 * self.frequency - (date.today() - period_start).days\n return int(price_per_day * days_not_used)","def billing_period_start(self): # ISO8601 or timestamp\n return self._safe_value(VAR_BILLINGPERIODSTART, int)","def period(self):\n return float(self._period) / 1000","def periodCheck(data):","def test_list_grading_periods_accounts(self):\r\n account_id = None # Change me!!\r\n\r\n r = self.client.list_grading_periods_accounts(account_id)","def between(cls, begin_date: datetime.date, end_date: datetime.date) -> float:\n\n if begin_date > end_date:\n raise ValueError('End date must not be before begin date.')\n if begin_date == end_date:\n return 0\n data = cls.cumulative()\n first = data.get((begin_date.year, begin_date.month), None)\n last = data.get((end_date.year, end_date.month), None)\n if first is None or last is None:\n raise ValidationError(\"Inflation figures don't cover entire period requested: {} - {}\".format(begin_date,\n end_date))\n return (last / first) - 1","def _period_from_date(self):\n if self.date['year']:\n if self.date['month']:\n if self.date['day']:\n self.period = Period.DAILY\n else:\n self.period = Period.MONTHLY\n else:\n self.period = Period.YEARLY\n else:\n self.period = Period.FULL","def block_period_consumption(self):\n return self._safe_value(VAR_BLOCKPERIODCONSUMPTION, float)","def current_effective_deadline(cls) -> float:","def remaining_days(self):\n if self.trialing or self.trial_ended:\n return self.remaining_trial_days\n else:\n return self.remaining_days_in_current_period","def get_periods():\n return [\n relativedelta(),\n relativedelta(days=6),\n relativedelta(months=1),\n relativedelta(months=3),\n relativedelta(years=1),\n relativedelta(years=5)\n ]","def get_last_period(self, status_id, company_payroll_id, config=None):\n if not config:\n config = self.env['ka_hr_payroll.config'].default_config()\n\n date_now = datetime.now().date()\n date_config = datetime.strptime(\"{0}-{1}-{2}\".format(date_now.year, date_now.month, config.date_start),\n DATE_FORMAT)\n date_config_str = date_config.strftime(DATE_FORMAT)\n\n return self.search([\n ('date_start', '<=', fields.Date.today()),\n ('status_id', 'parent_of', status_id),\n ('state', '=', 'done'),\n ('state_rapel', '!=', '1'),\n ('date_done', '<', date_config_str),\n ('company_payroll_id', '=', company_payroll_id)\n ], limit=1, order='date_start desc')","def kind(self):\n return DateValueTypes.PERIOD","def get_period(self):\n raise NotImplementedError('Agent is an abstract base class')","def InactiveNoEndDate(obj):\n if not obj.active_p:\n if not (obj.end_date):\n raise interface.Invalid(\n _(\"If a person is inactive End Date must be set\"), \n \"end_date\", \n \"active_p\")","def availableWorkersDuringPeriod(self, begin, end):\n availableWorkers = []\n for worker in self._workers:\n if worker.availableInPeriod(begin, end):\n availableWorkers.append(worker)\n return availableWorkers","def find_period_below(self, start, end, target, length):\n\n if start > end:\n raise ValueError(\"End needs to be after start!\")\n if length < 0:\n raise ValueError(\"Period length must be larger than zero!\")\n\n period_start = (start if self.get(start) <= target else None)\n\n start_ix = self._trace.bisect_right(start)\n end_ix = self._trace.bisect_left(end)\n for time, lvl in self._trace.items()[start_ix:end_ix]:\n # Period long enough?\n if period_start is not None:\n if time >= period_start + length:\n return period_start\n # Not enough space until end?\n elif time + length > end:\n return None\n # Above target? Reset period\n if lvl > target:\n period_start = None\n else:\n if period_start is None:\n period_start = time\n\n # Possible at end?\n if period_start is not None and period_start+length <= end:\n return period_start\n\n # Nothing found\n return None","def valid_until(self):\n return self._valid_until / 10000000","def get_time_period(value):\n\t\tfor time_period in TimePeriod:\n\t\t\tif time_period.period == value:\n\t\t\t\treturn time_period\n\t\traise ValueError('{} is not a valid TimePeriod'.format(value))","def get_current_fiscal_year(self):\n current_date = datetime.today().date()\n for year in self.fiscal_years.all():\n if year.begin_date < current_date < year.end_date:\n return year\n return None","def _getTimePeriod(self):\n if isinstance(self.period, tuple):\n period = self.soapCustomDateRange % \\\n (self.soapCustomDate % (self.period[1].day,\n self.period[1].month,\n self.period[1].year),\n self.soapCustomDate % (self.period[0].day,\n self.period[0].month,\n self.period[0].year))\n else:\n period = self.soapPredefinedTime % self.period\n self.logger.debug(\"period = %s\", period)\n return period","def getReportingPeriod(begin, end, week, month, year, last):\n if begin and end:\n rval = (datetime.strptime(begin, '%Y-%m-%d'),\n datetime.strptime(end, '%Y-%m-%d'))\n elif week or month or year:\n if last:\n rval = 'Last'\n else:\n rval = 'This'\n if week:\n rval += 'Week'\n elif month:\n rval += 'Month'\n else:\n rval += 'Year'\n else:\n rval = 'Yesterday'\n return rval","def in_grace_period_count(self):\n if \"inGracePeriodCount\" in self._prop_dict:\n return self._prop_dict[\"inGracePeriodCount\"]\n else:\n return None","def get_period(self, df, key):\n daysFiltered = self.filter_days(df, **self.periods[key]['days'])\n perStart = string_date(self.periods[key]['dates'][0], df.index[0].date().year)\n perEnd = string_date(self.periods[key]['dates'][1], df.index[0].date().year)\n if self.spans_year(key):\n # slice period for beginning of the year\n fall = daysFiltered.ix[perStart:string_date('12/31', df.index[0].date().year)]\n fall = fall.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\n fall = fall.sort_index()\n # slice period for end of the year\n spring = fall.append(daysFiltered.ix[string_date('1/1', df.index[0].date().year):perEnd])\n spring = spring.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\n spring = spring.sort_index()\n return(spring.rename_axis({'data': key}, axis=1))\n else:\n df_temp = daysFiltered.ix[perStart:perEnd]\n df_temp = df_temp.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\n return(df_temp.rename_axis({'data': key}, axis=1))","def amount_already_paid_in_period(self):\n assert self.type == \"N\", _(\"Subscription must be normal to use this method\")\n period_start, period_end = self.get_current_period()\n price_per_day = (\n self.get_price_for_full_period() / (period_end - period_start).days\n )\n days_already_used = (date.today() - period_start).days\n amount = int(price_per_day * days_already_used)\n if amount > self.get_price_for_full_period():\n amount = self.get_price_for_full_period()\n if amount < 0:\n amount = 0\n return amount","def get_employees_born_in_period(cls, start_date, end_date,\n strategy=lazyload):\n cls._check_strategy(strategy)\n\n employees = db.session.query(Employee).options(\n strategy(Employee.department)\n ).filter(\n and_(\n Employee.date_of_birth > start_date,\n Employee.date_of_birth < end_date\n )\n ).all()\n return employees","def dispatch_interval(self):\n start = self.start\n start_date = start.date()\n\n # add zero padding to make period_id 3 chars long\n period_id = str(self.period_id).zfill(3)\n\n if start.hour < 4 and period_id != \"001\":\n start_date = start_date - timedelta(days=1)\n\n # Concat zero-padded dates and add period id\n dispatch_interval = \"\".join([start_date.strftime(\"%Y%m%d\"), period_id])\n\n return dispatch_interval","def get_debt_state(member, limit_year, limit_month):\n if member.first_payment_year is None:\n # never paid! using registration date to start with\n yearmonths_paid = set()\n year_to_check = member.registration_date.year\n month_to_check = member.registration_date.month\n else:\n # build a set for the year/month of paid quotas\n quotas = Quota.objects.filter(member=member).all()\n yearmonths_paid = {(q.year, q.month) for q in quotas}\n\n year_to_check = member.first_payment_year\n month_to_check = member.first_payment_month\n\n # verify the limit is after member started paying\n if year_to_check == limit_year:\n if month_to_check > limit_month:\n return []\n elif year_to_check > limit_year:\n return []\n\n # build a set of all the year/month the member should have paid up to (including) the limit\n should_have_paid = set()\n while True:\n should_have_paid.add((year_to_check, month_to_check))\n year_to_check, month_to_check = increment_year_month(year_to_check, month_to_check)\n if year_to_check == limit_year:\n if month_to_check > limit_month:\n break\n elif year_to_check > limit_year:\n break\n\n return sorted(should_have_paid - yearmonths_paid)","def is_inactive(self):\n now = datetime.datetime.now()\n return not (self.start_date < now < self.end_date)","def periods(self) -> localedata.LocaleDataDict:\n try:\n return self._data['day_periods']['stand-alone']['wide']\n except KeyError:\n return localedata.LocaleDataDict({}) # pragma: no cover","def _get_default_period(self, cr, uid, context=None):\n context = context or {}\n if context.get('period_id', False):\n return context['period_id']\n account_period_obj = self.pool.get('account.period')\n ctx = dict(context, account_period_prefer_normal=True)\n ids = account_period_obj.find(cr, uid, context=ctx)\n period_id = False\n if ids:\n period_id = ids[0]\n return period_id","def valid_from(self) -> datetime:\n return self._valid_from","def find_suitable_period():\n # The highest acceptable factor will be the square root of the size.\n highest_acceptable_factor = int(math.sqrt(SIZE))\n\n # Too high a factor (eg SIZE/2) and the interval is too small, too \n # low (eg 2) and the period is too small.\n # We would prefer it to be lower than the number of VALID_CHARS, but more\n # than say 4.\n starting_point = len(VALID_CHARS) > 14 and len(VALID_CHARS)/2 or 13\n for p in range(starting_point, 7, -1) \\\n + range(highest_acceptable_factor, starting_point+1, -1) \\\n + [6,5,4,3,2]:\n if SIZE % p == 0:\n return p\n raise Exception, \"No valid period could be found for SIZE=%d.\\n\" \\\n \"Try avoiding prime numbers :-)\" % SIZE","def failing_periods(self) -> 'outputs.DynamicThresholdFailingPeriodsResponse':\n return pulumi.get(self, \"failing_periods\")","def validate_check_in_period(check_in_period):\n if not check_in_period:\n check_in_period = 30\n if not isinstance(check_in_period, int):\n try:\n check_in_period = int(check_in_period)\n except ValueError:\n print \"Incorrect check-in period given. Setting to 30.\"\n check_in_period = 30\n\n return check_in_period","def pnl(qbo_session, period = \"YEARLY\", start_date=\"first\", end_date=\"last\",\n **kwargs):\n\n pnl_account_types = [\n \n \"Income\", \"Other Income\",\n \"Expense\", \"Other Expense\", \"Cost of Goods Sold\"\n \n ]\n\n \n\n # go through the accounts, collecting a list of those that are \n # pnl accounts\n\n relevant_accounts = []\n\n coa = qbo_session.chart_of_accounts()\n\n AccountType_i = coa[0].index(\"AccountType\")\n fqa_i = coa[0].index(\"FullyQualifiedName\")\n\n for a in coa:\n\n AccountType = a[AccountType_i]\n\n if AccountType in pnl_account_types:\n\n relevant_accounts.append(a[fqa_i])\n \n # now collect the ledger_lines that are even relevant to the time\n # period and pnl accounts (and we'll handle presentation last)\n\n relevant_activity = {} #{account:[relevant lines]}\n\n all_ledger_lines = qbo_session.ledger_lines(None, None, None, True,\n **kwargs)\n\n headers = all_ledger_lines[0]\n\n account_i = headers.index(\"account\") \n amount_i = headers.index(\"amount\")\n date_i = headers.index(\"TxnDate\")\n \n earliest_date = datetime(2100,1,1)\n latest_date = datetime(1900,1,1)\n\n for line in all_ledger_lines[1:]:\n\n account = line[account_i]\n line_date = line[date_i]\n\n #first apply the date filter!\n if not start_date == \"first\" and line_date < start_date:\n continue\n \n if not end_date == \"last\" and line_date > end_date:\n continue\n \n #if it's made the cut, we can update the report date bounds\n earliest_date = min(line_date,earliest_date)\n latest_date = max(line_date,latest_date)\n\n #then apply the account filter!\n\n if not account in relevant_activity:\n #then let's confirm that its account type is a pnl one\n \n if not account in relevant_accounts:\n \n continue\n\n else:\n relevant_activity[account] = []\n\n relevant_activity[account].append(line)\n\n #now let's do presentation\n #TODO -- incorporate pandas tables...do only minimal work on it until then\n\n pnl_lines = []\n\n if period == \"YEARLY\":\n\n report_start_date = datetime(earliest_date.year,1,1)\n report_end_date = datetime(latest_date.year,12,31)\n\n period_start_dates = list(rrule(YEARLY, bymonth=1, bymonthday=1,\n dtstart=report_start_date,\n until=report_end_date))\n\n period_end_dates = list(rrule(YEARLY, bymonth=12, bymonthday=-1,\n dtstart=report_start_date,\n until=report_end_date))\n\n elif period == \"MONTHLY\":\n\n report_start_date = datetime(earliest_date.year,\n earliest_date.month,\n 1)\n report_end_date = datetime(latest_date.year,\n latest_date.month,\n calendar.monthrange(latest_date.year,\n latest_date.month)[1])\n\n period_start_dates = list(rrule(MONTHLY, bymonthday=1,\n dtstart=report_start_date,\n until=report_end_date))\n\n period_end_dates = list(rrule(YEARLY, bymonthday=-1,\n dtstart=report_start_date,\n until=report_end_date)) \n\n header_1 = [\"\", \"Period Start -->\"] + period_start_dates\n header_2 = [\"Account\", \"Period End -->\"] + period_end_dates\n\n pnl_lines.append(header_1)\n pnl_lines.append(header_2)\n\n \"\"\"Clearly, there's a way to do this with only one pass of the data...\n let's get that right in the first re-write...probably with pandas\"\"\"\n\n #now let's fill up the pnl_lines with what we know to be the relevant data\n #for now, we'll rely on the knowledge that the data is coming to us in\n #date order, but that should be fixed too...\n\n for account in relevant_activity:\n\n account_row = [account, \"\"] #one value per period \n\n current_period_index = 0 #primitive counter, yes!\n this_period_total = 0 #this will be this period's total\n\n for line in relevant_activity[account]:\n \n line_amount = line[amount_i]\n line_date = line[date_i] \n\n if line_date > period_end_dates[current_period_index]:\n\n account_row.append(this_period_total)\n this_period_total = line_amount\n current_period_index +=1\n\n else:\n \n this_period_total = round(this_period_total +\n line_amount, 2)\n\n \"\"\"super sloppy...\"\"\"\n account_row.append(this_period_total) #for the last period\n current_period_index +=1\n\n while current_period_index < len(period_end_dates):\n account_row.append(0)\n current_period_index +=1\n\n pnl_lines.append(account_row)\n\n return pnl_lines","def period(self):\n return f\"{self.measurement_date.year}/{self.measurement_date.month}\"","def quantaHandledByPeriod(self, period):\n\n start_datetime = self.start_time.to_python_datetime()\n end_datetime = self.end_time.to_python_datetime()\n\n total_quanta = 0\n\n # Iterate through the quanta of the period, while the starting_quanta is less\n # than the ending quanta\n\n quanta_start_time = period.start_time\n while quanta_start_time < period.end_time:\n quanta_end_time = quanta_start_time + timedelta(minutes=granularity_in_minutes())\n\n if start_datetime <= quanta_start_time < end_datetime:\n if start_datetime < quanta_end_time <= end_datetime:\n total_quanta = total_quanta + 1\n\n quanta_start_time = quanta_start_time + timedelta(minutes=granularity_in_minutes())\n\n return total_quanta","def limit_date_range_from(self):\n return self._limit_date_range_from","def determine_periods(obj):\n return obj[len(obj)-1][\"period\"]","def grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"grace_period\")","def grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"grace_period\")","def grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"grace_period\")","def grace_period(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"grace_period\")","def current_quarter_end(start_year:int, start_month:int, logger:lg.Logger = None) -> date:\n if logger:\n logger.info(F\"start year = {start_year}; start month = {start_month}\")\n end_year, end_month = next_quarter_start(start_year, start_month)\n # end date is one day back from the start of the next period\n return date(end_year, end_month, 1) - ONE_DAY","def last(self) -> 'outputs.CommitmentPeriodResponse':\n return pulumi.get(self, \"last\")"],"string":"[\n \"def get_current_valid_accounting_period():\\n current_valid_accounting_period = None\\n for accounting_period in AccountingPeriod.objects.all():\\n if accounting_period.begin < date.today() and accounting_period.end > date.today():\\n return accounting_period\\n if not current_valid_accounting_period:\\n raise AccountingPeriodNotFound()\",\n \"def getCurrentValidAccountingPeriod():\\n currentValidAccountingPeriod = None\\n for accountingPeriod in AccountingPeriod.objects.all():\\n if accountingPeriod.begin < date.today() and accountingPeriod.end > date.today():\\n return accountingPeriod\\n if currentValidAccountingPeriod == None:\\n raise NoFeasableAccountingPeriodFound()\",\n \"def get_current_period(self):\\n if not self.next_billing:\\n return None\\n assert self.type == \\\"N\\\", _(\\\"Subscription must be normal to use this method\\\")\\n start = self.next_billing - relativedelta(months=self.frequency)\\n end = self.next_billing\\n return start, end\",\n \"def current_period(self):\\n return self._current_period\",\n \"def getAllPriorAccountingPeriods(targetAccountingPeriod):\\n currentValidAccountingPeriod = None\\n accountingPeriods = []\\n for accountingPeriod in AccountingPeriod.objects.all():\\n if accountingPeriod.end < targetAccountingPeriod.begin:\\n accountingPeriods.append(accountingPeriod)\\n if accountingPeriods == []:\\n raise NoPriorAccountingPeriodFound()\\n return accountingPeriods\",\n \"def period(self):\\n return self.__period\",\n \"def getPeriod(self):\\n return StripePeriod(self.base.get(\\\"period\\\", []))\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"period\\\")\",\n \"def __get_period(self):\\n return self.__period\",\n \"def planning_period(self):\\n return self._planning_period\",\n \"def get_chart_period(self,req):\\n now=int(DATE())\\n period=INT(req.period) # allow for it having been a string\\n if period>9999: # assume it is a month\\n if period<(now//100): # a valid complete previous month\\n prior=True# this is a previous month\\n else:\\n period=now//100 # default to current month\\n prior=False\\n start=period*100+1\\n end=self.nextperiod(period)*100+1\\n else: # assume it is a year\\n if period and (period<(now//10000)): # a prior year\\n prior=True# this is a previous year\\n else:\\n##\\n# period=now//100 # default to current month\\n# prior=False\\n# start=period*100+1\\n# end=self.nextperiod(period)*100+1\\n##\\n period=now//10000 # default to current year\\n prior=False\\n start=period*10000+101\\n end=self.nextperiod(period)*10000+101\\n return period,start,end,prior\",\n \"def billing_period(self) -> Optional[str]:\\n return pulumi.get(self, \\\"billing_period\\\")\",\n \"def get_interval(self):\\n return self._period\",\n \"def get_period(self):\\n # res\\n if self._cacheExpiration <= YAPI.GetTickCount():\\n if self.load(YAPI._yapiContext.GetCacheValidity()) != YAPI.SUCCESS:\\n return YPwmOutput.PERIOD_INVALID\\n res = self._period\\n return res\",\n \"def get_period_range(self, period, start, end, inclusive_start=True, inclusive_end=True):\\n if not isinstance(start, datetime.datetime):\\n start = self.get_date_from_string(start, '%Y-%m-%d')\\n if not isinstance(end, datetime.datetime):\\n end = self.get_date_from_string(end, '%Y-%m-%d')\\n\\n if period == 'month':\\n get_period = self.get_current_month_range\\n get_next_period = self.get_next_month\\n get_previous_period = self.get_previous_month\\n if period == 'week':\\n get_period = self.get_current_week_range\\n get_next_period = self.get_next_week\\n get_previous_period = self.get_previous_week\\n\\n #####################\\n # inclusive_start means that the result set will include the whole period\\n # containing the start date. Likewise for inclusive_end.\\n #\\n # If you are, say, reporting on a 'last completed month' or something,\\n # but your report date (and end date) is mid-month or something, then setting 'inclusive_end'\\n # to False will insure that the report ends with the month prior to the\\n # end date.\\n #\\n # If you're doing projections starting with the month following the one\\n # you're in, setting inclusive_start to False will insure that the first\\n # period in the range is the one *after* the period you're in now.\\n #######################\\n if not inclusive_start:\\n start = get_next_period(start)[0]\\n if not inclusive_end:\\n end = get_previous_period(end)[1]\\n\\n returnvals = []\\n\\n\\n firstper = get_period(start)\\n returnvals.append(firstper)\\n per = firstper\\n while per[1] < end:\\n # goes as long as the *end* of the period is < our end date.\\n # the intent is that if end is 2010-10-04, the last period will be\\n # (2010-10-01, 2010-10-31)\\n per = get_next_period(per[1])\\n returnvals.append(per)\\n\\n return returnvals\",\n \"def get_period_guarantee_faithful_compliance(self):\\n return ceiling(self.get_period_faithful_compliance, 3)\",\n \"def remaining_days_in_current_period(self):\\n try:\\n return self.count_days_from_now(self.current_period_ends_at)\\n except AttributeError:\\n return 0\",\n \"def expected_last_period_end(self):\\n return self._expected_last_period_end\",\n \"def getBeginEnd(self):\\n if (self.dr_type == choices.DATE_RANGE_TYPE_FIXED):\\n return self.begin, self.end\\n\\n elif (self.dr_type == choices.DATE_RANGE_TYPE_VARIABLE):\\n end = datetime.now()\\n\\n if (self.unit == choices.TIME_UNIT_DAY):\\n begin = end - relativedelta(days=self.quantity)\\n\\n elif (self.unit == choices.TIME_UNIT_WEEK):\\n begin = end - relativedelta(weeks=self.quantity)\\n\\n elif (self.unit == choices.TIME_UNIT_MONTH):\\n begin = end - relativedelta(months=self.quantity)\\n\\n elif (self.unit == choices.TIME_UNIT_YEAR):\\n begin = end - relativedelta(years=self.quantity)\\n\\n else:\\n # This case should not happen\\n raise Exception(\\\"A DateRange object's 'unit' must be a numeric\\\"\\n \\\" value in: {units}.\\\".format(units=\\\", \\\".join([\\n \\\"{const} ({name})\\\".format(const=unit, name=unit_name)\\n for unit, unit_name in choices.TIME_UNIT\\n if unit is not None]))\\n )\\n\\n return begin, end\\n\\n else:\\n # This case should not happen\\n raise Exception(\\\"A DateRange object's 'dr_type' must be one of:\\\"\\n \\\" {const_fixed} (fixed range) or {const_dynamic}\\\"\\n \\\" (dynamic range).\\\".format(\\n const_fixed=choices.DATE_RANGE_TYPE_FIXED,\\n const_dynamic=choices.DATE_RANGE_TYPE_VARIABLE\\n ))\",\n \"def _get_period(self, cr, uid, context={}):\\n\\n account_period_obj = self.pool.get('account.period')\\n ids = account_period_obj.find(\\n cr, uid, time.strftime('%Y-%m-%d'), context=context)\\n period_id = ids[0]\\n return period_id\",\n \"def real_period(self):\\n return max(\\n self.period * self.PERIOD_MARGIN_FACTOR -\\n (self.max_lag if self.max_lag else self.lag * self.LAG_MARGIN_FACTOR),\\n 0.0)\",\n \"def checkpoint_period_get(self):\\n raise Exception(\\\"TODO\\\")\",\n \"def current(self) -> Optional['outputs.CommitmentPeriodResponse']:\\n return pulumi.get(self, \\\"current\\\")\",\n \"def renewal_period(self) -> Optional[float]:\\n return pulumi.get(self, \\\"renewal_period\\\")\",\n \"def valid_period(request):\\n return request.param\",\n \"def valid_until(self) -> datetime:\\n return self._valid_until\",\n \"def date_validity(self):\\n return self._date_validity\",\n \"def period(self) -> int:\",\n \"def get_first_period(start_record, end_record, start_period, end_period):\\n start_record, end_record, start_period, end_period = to_datetime(start_record, end_record, start_period, end_period)\\n pspan = end_period - start_period\\n delta_year = relativedelta(years=1)\\n # what is the first day of year of the start of the period that fits the record?\\n start_rec_year = start_record.year\\n d = datetime(start_rec_year, start_period.month, start_period.day)\\n if d < start_record:\\n d = d + delta_year\\n delta_years = start_period.year - d.year\\n e = end_period + relativedelta(years=-delta_years)\\n return (d, e)\",\n \"def orbital_period(self):\\n return self._orbital_period\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def evaluation_periods(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"evaluation_periods\\\")\",\n \"def get_period_guarantee_advance(self):\\n return ceiling(self.scheduled_completion, 3)\",\n \"def _get_period(self, cr, uid, context=None):\\n context = context or {}\\n if context.get('period_id', False):\\n return context['period_id']\\n account_period_obj = self.pool.get('account.period')\\n ctx = dict(context, account_period_prefer_normal=True)\\n ids = account_period_obj.find(cr, uid, context=ctx)\\n period_id = False\\n if ids:\\n period_id = ids[0]\\n return period_id\",\n \"def sleepPeriodValidate(self):\\n # sleep_validate = False (not in sleep period)\\n # sleep_validate = True (in sleep period)\\n \\n sleep_validate = None\\n pre_midnight = '23:59'\\n midnight = '00:00'\\n \\n # check if out of sleep period\\n if self.current_time >= self.sleep_stop and self.current_time < self.sleep_start:\\n sleep_validate = False\\n \\n # check if in sleep period\\n elif self.current_time >= self.sleep_start and self.current_time <= pre_midnight:\\n sleep_validate = True \\n elif self.current_time < self.sleep_stop and self.current_time > midnight:\\n sleep_validate = True\\n \\n return sleep_validate\",\n \"def get_period_budgets(cls, now):\\n limits_dict = {}\\n strategies = cls.objects_visible.filter(is_distributed_evenly=True)\\n strategies = cls.running(strategies)\\n\\n for strategy in strategies:\\n limits_dict[strategy.public_id] = strategy.period_budget(now)\\n\\n log.info('[SPENDINGS] Period budgets calculated (currency): {0}'.format(limits_dict))\\n\\n # Cast to budget precision used in Redis\\n return {strategy: cast_CPM_to_dbbid(cast_currency_to_CPM(budget)) for strategy, budget in limits_dict.items()}\",\n \"def getUpdatePeriod( self, obj=None ):\\n if obj is not None:\\n period = self.getSyndicationInfo(obj).period\\n else:\\n period = self.period\\n return period\",\n \"def amount_to_pay_in_period(self):\\n assert self.type == \\\"N\\\", _(\\\"Subscription must be normal to use this method\\\")\\n period_start, period_end = self.get_current_period()\\n price_per_day = (\\n self.get_price_for_full_period() / (period_end - period_start).days\\n )\\n days_not_used = 30 * self.frequency - (date.today() - period_start).days\\n return int(price_per_day * days_not_used)\",\n \"def billing_period_start(self): # ISO8601 or timestamp\\n return self._safe_value(VAR_BILLINGPERIODSTART, int)\",\n \"def period(self):\\n return float(self._period) / 1000\",\n \"def periodCheck(data):\",\n \"def test_list_grading_periods_accounts(self):\\r\\n account_id = None # Change me!!\\r\\n\\r\\n r = self.client.list_grading_periods_accounts(account_id)\",\n \"def between(cls, begin_date: datetime.date, end_date: datetime.date) -> float:\\n\\n if begin_date > end_date:\\n raise ValueError('End date must not be before begin date.')\\n if begin_date == end_date:\\n return 0\\n data = cls.cumulative()\\n first = data.get((begin_date.year, begin_date.month), None)\\n last = data.get((end_date.year, end_date.month), None)\\n if first is None or last is None:\\n raise ValidationError(\\\"Inflation figures don't cover entire period requested: {} - {}\\\".format(begin_date,\\n end_date))\\n return (last / first) - 1\",\n \"def _period_from_date(self):\\n if self.date['year']:\\n if self.date['month']:\\n if self.date['day']:\\n self.period = Period.DAILY\\n else:\\n self.period = Period.MONTHLY\\n else:\\n self.period = Period.YEARLY\\n else:\\n self.period = Period.FULL\",\n \"def block_period_consumption(self):\\n return self._safe_value(VAR_BLOCKPERIODCONSUMPTION, float)\",\n \"def current_effective_deadline(cls) -> float:\",\n \"def remaining_days(self):\\n if self.trialing or self.trial_ended:\\n return self.remaining_trial_days\\n else:\\n return self.remaining_days_in_current_period\",\n \"def get_periods():\\n return [\\n relativedelta(),\\n relativedelta(days=6),\\n relativedelta(months=1),\\n relativedelta(months=3),\\n relativedelta(years=1),\\n relativedelta(years=5)\\n ]\",\n \"def get_last_period(self, status_id, company_payroll_id, config=None):\\n if not config:\\n config = self.env['ka_hr_payroll.config'].default_config()\\n\\n date_now = datetime.now().date()\\n date_config = datetime.strptime(\\\"{0}-{1}-{2}\\\".format(date_now.year, date_now.month, config.date_start),\\n DATE_FORMAT)\\n date_config_str = date_config.strftime(DATE_FORMAT)\\n\\n return self.search([\\n ('date_start', '<=', fields.Date.today()),\\n ('status_id', 'parent_of', status_id),\\n ('state', '=', 'done'),\\n ('state_rapel', '!=', '1'),\\n ('date_done', '<', date_config_str),\\n ('company_payroll_id', '=', company_payroll_id)\\n ], limit=1, order='date_start desc')\",\n \"def kind(self):\\n return DateValueTypes.PERIOD\",\n \"def get_period(self):\\n raise NotImplementedError('Agent is an abstract base class')\",\n \"def InactiveNoEndDate(obj):\\n if not obj.active_p:\\n if not (obj.end_date):\\n raise interface.Invalid(\\n _(\\\"If a person is inactive End Date must be set\\\"), \\n \\\"end_date\\\", \\n \\\"active_p\\\")\",\n \"def availableWorkersDuringPeriod(self, begin, end):\\n availableWorkers = []\\n for worker in self._workers:\\n if worker.availableInPeriod(begin, end):\\n availableWorkers.append(worker)\\n return availableWorkers\",\n \"def find_period_below(self, start, end, target, length):\\n\\n if start > end:\\n raise ValueError(\\\"End needs to be after start!\\\")\\n if length < 0:\\n raise ValueError(\\\"Period length must be larger than zero!\\\")\\n\\n period_start = (start if self.get(start) <= target else None)\\n\\n start_ix = self._trace.bisect_right(start)\\n end_ix = self._trace.bisect_left(end)\\n for time, lvl in self._trace.items()[start_ix:end_ix]:\\n # Period long enough?\\n if period_start is not None:\\n if time >= period_start + length:\\n return period_start\\n # Not enough space until end?\\n elif time + length > end:\\n return None\\n # Above target? Reset period\\n if lvl > target:\\n period_start = None\\n else:\\n if period_start is None:\\n period_start = time\\n\\n # Possible at end?\\n if period_start is not None and period_start+length <= end:\\n return period_start\\n\\n # Nothing found\\n return None\",\n \"def valid_until(self):\\n return self._valid_until / 10000000\",\n \"def get_time_period(value):\\n\\t\\tfor time_period in TimePeriod:\\n\\t\\t\\tif time_period.period == value:\\n\\t\\t\\t\\treturn time_period\\n\\t\\traise ValueError('{} is not a valid TimePeriod'.format(value))\",\n \"def get_current_fiscal_year(self):\\n current_date = datetime.today().date()\\n for year in self.fiscal_years.all():\\n if year.begin_date < current_date < year.end_date:\\n return year\\n return None\",\n \"def _getTimePeriod(self):\\n if isinstance(self.period, tuple):\\n period = self.soapCustomDateRange % \\\\\\n (self.soapCustomDate % (self.period[1].day,\\n self.period[1].month,\\n self.period[1].year),\\n self.soapCustomDate % (self.period[0].day,\\n self.period[0].month,\\n self.period[0].year))\\n else:\\n period = self.soapPredefinedTime % self.period\\n self.logger.debug(\\\"period = %s\\\", period)\\n return period\",\n \"def getReportingPeriod(begin, end, week, month, year, last):\\n if begin and end:\\n rval = (datetime.strptime(begin, '%Y-%m-%d'),\\n datetime.strptime(end, '%Y-%m-%d'))\\n elif week or month or year:\\n if last:\\n rval = 'Last'\\n else:\\n rval = 'This'\\n if week:\\n rval += 'Week'\\n elif month:\\n rval += 'Month'\\n else:\\n rval += 'Year'\\n else:\\n rval = 'Yesterday'\\n return rval\",\n \"def in_grace_period_count(self):\\n if \\\"inGracePeriodCount\\\" in self._prop_dict:\\n return self._prop_dict[\\\"inGracePeriodCount\\\"]\\n else:\\n return None\",\n \"def get_period(self, df, key):\\n daysFiltered = self.filter_days(df, **self.periods[key]['days'])\\n perStart = string_date(self.periods[key]['dates'][0], df.index[0].date().year)\\n perEnd = string_date(self.periods[key]['dates'][1], df.index[0].date().year)\\n if self.spans_year(key):\\n # slice period for beginning of the year\\n fall = daysFiltered.ix[perStart:string_date('12/31', df.index[0].date().year)]\\n fall = fall.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\\n fall = fall.sort_index()\\n # slice period for end of the year\\n spring = fall.append(daysFiltered.ix[string_date('1/1', df.index[0].date().year):perEnd])\\n spring = spring.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\\n spring = spring.sort_index()\\n return(spring.rename_axis({'data': key}, axis=1))\\n else:\\n df_temp = daysFiltered.ix[perStart:perEnd]\\n df_temp = df_temp.between_time(self.periods[key]['times'][0], self.periods[key]['times'][1])\\n return(df_temp.rename_axis({'data': key}, axis=1))\",\n \"def amount_already_paid_in_period(self):\\n assert self.type == \\\"N\\\", _(\\\"Subscription must be normal to use this method\\\")\\n period_start, period_end = self.get_current_period()\\n price_per_day = (\\n self.get_price_for_full_period() / (period_end - period_start).days\\n )\\n days_already_used = (date.today() - period_start).days\\n amount = int(price_per_day * days_already_used)\\n if amount > self.get_price_for_full_period():\\n amount = self.get_price_for_full_period()\\n if amount < 0:\\n amount = 0\\n return amount\",\n \"def get_employees_born_in_period(cls, start_date, end_date,\\n strategy=lazyload):\\n cls._check_strategy(strategy)\\n\\n employees = db.session.query(Employee).options(\\n strategy(Employee.department)\\n ).filter(\\n and_(\\n Employee.date_of_birth > start_date,\\n Employee.date_of_birth < end_date\\n )\\n ).all()\\n return employees\",\n \"def dispatch_interval(self):\\n start = self.start\\n start_date = start.date()\\n\\n # add zero padding to make period_id 3 chars long\\n period_id = str(self.period_id).zfill(3)\\n\\n if start.hour < 4 and period_id != \\\"001\\\":\\n start_date = start_date - timedelta(days=1)\\n\\n # Concat zero-padded dates and add period id\\n dispatch_interval = \\\"\\\".join([start_date.strftime(\\\"%Y%m%d\\\"), period_id])\\n\\n return dispatch_interval\",\n \"def get_debt_state(member, limit_year, limit_month):\\n if member.first_payment_year is None:\\n # never paid! using registration date to start with\\n yearmonths_paid = set()\\n year_to_check = member.registration_date.year\\n month_to_check = member.registration_date.month\\n else:\\n # build a set for the year/month of paid quotas\\n quotas = Quota.objects.filter(member=member).all()\\n yearmonths_paid = {(q.year, q.month) for q in quotas}\\n\\n year_to_check = member.first_payment_year\\n month_to_check = member.first_payment_month\\n\\n # verify the limit is after member started paying\\n if year_to_check == limit_year:\\n if month_to_check > limit_month:\\n return []\\n elif year_to_check > limit_year:\\n return []\\n\\n # build a set of all the year/month the member should have paid up to (including) the limit\\n should_have_paid = set()\\n while True:\\n should_have_paid.add((year_to_check, month_to_check))\\n year_to_check, month_to_check = increment_year_month(year_to_check, month_to_check)\\n if year_to_check == limit_year:\\n if month_to_check > limit_month:\\n break\\n elif year_to_check > limit_year:\\n break\\n\\n return sorted(should_have_paid - yearmonths_paid)\",\n \"def is_inactive(self):\\n now = datetime.datetime.now()\\n return not (self.start_date < now < self.end_date)\",\n \"def periods(self) -> localedata.LocaleDataDict:\\n try:\\n return self._data['day_periods']['stand-alone']['wide']\\n except KeyError:\\n return localedata.LocaleDataDict({}) # pragma: no cover\",\n \"def _get_default_period(self, cr, uid, context=None):\\n context = context or {}\\n if context.get('period_id', False):\\n return context['period_id']\\n account_period_obj = self.pool.get('account.period')\\n ctx = dict(context, account_period_prefer_normal=True)\\n ids = account_period_obj.find(cr, uid, context=ctx)\\n period_id = False\\n if ids:\\n period_id = ids[0]\\n return period_id\",\n \"def valid_from(self) -> datetime:\\n return self._valid_from\",\n \"def find_suitable_period():\\n # The highest acceptable factor will be the square root of the size.\\n highest_acceptable_factor = int(math.sqrt(SIZE))\\n\\n # Too high a factor (eg SIZE/2) and the interval is too small, too \\n # low (eg 2) and the period is too small.\\n # We would prefer it to be lower than the number of VALID_CHARS, but more\\n # than say 4.\\n starting_point = len(VALID_CHARS) > 14 and len(VALID_CHARS)/2 or 13\\n for p in range(starting_point, 7, -1) \\\\\\n + range(highest_acceptable_factor, starting_point+1, -1) \\\\\\n + [6,5,4,3,2]:\\n if SIZE % p == 0:\\n return p\\n raise Exception, \\\"No valid period could be found for SIZE=%d.\\\\n\\\" \\\\\\n \\\"Try avoiding prime numbers :-)\\\" % SIZE\",\n \"def failing_periods(self) -> 'outputs.DynamicThresholdFailingPeriodsResponse':\\n return pulumi.get(self, \\\"failing_periods\\\")\",\n \"def validate_check_in_period(check_in_period):\\n if not check_in_period:\\n check_in_period = 30\\n if not isinstance(check_in_period, int):\\n try:\\n check_in_period = int(check_in_period)\\n except ValueError:\\n print \\\"Incorrect check-in period given. Setting to 30.\\\"\\n check_in_period = 30\\n\\n return check_in_period\",\n \"def pnl(qbo_session, period = \\\"YEARLY\\\", start_date=\\\"first\\\", end_date=\\\"last\\\",\\n **kwargs):\\n\\n pnl_account_types = [\\n \\n \\\"Income\\\", \\\"Other Income\\\",\\n \\\"Expense\\\", \\\"Other Expense\\\", \\\"Cost of Goods Sold\\\"\\n \\n ]\\n\\n \\n\\n # go through the accounts, collecting a list of those that are \\n # pnl accounts\\n\\n relevant_accounts = []\\n\\n coa = qbo_session.chart_of_accounts()\\n\\n AccountType_i = coa[0].index(\\\"AccountType\\\")\\n fqa_i = coa[0].index(\\\"FullyQualifiedName\\\")\\n\\n for a in coa:\\n\\n AccountType = a[AccountType_i]\\n\\n if AccountType in pnl_account_types:\\n\\n relevant_accounts.append(a[fqa_i])\\n \\n # now collect the ledger_lines that are even relevant to the time\\n # period and pnl accounts (and we'll handle presentation last)\\n\\n relevant_activity = {} #{account:[relevant lines]}\\n\\n all_ledger_lines = qbo_session.ledger_lines(None, None, None, True,\\n **kwargs)\\n\\n headers = all_ledger_lines[0]\\n\\n account_i = headers.index(\\\"account\\\") \\n amount_i = headers.index(\\\"amount\\\")\\n date_i = headers.index(\\\"TxnDate\\\")\\n \\n earliest_date = datetime(2100,1,1)\\n latest_date = datetime(1900,1,1)\\n\\n for line in all_ledger_lines[1:]:\\n\\n account = line[account_i]\\n line_date = line[date_i]\\n\\n #first apply the date filter!\\n if not start_date == \\\"first\\\" and line_date < start_date:\\n continue\\n \\n if not end_date == \\\"last\\\" and line_date > end_date:\\n continue\\n \\n #if it's made the cut, we can update the report date bounds\\n earliest_date = min(line_date,earliest_date)\\n latest_date = max(line_date,latest_date)\\n\\n #then apply the account filter!\\n\\n if not account in relevant_activity:\\n #then let's confirm that its account type is a pnl one\\n \\n if not account in relevant_accounts:\\n \\n continue\\n\\n else:\\n relevant_activity[account] = []\\n\\n relevant_activity[account].append(line)\\n\\n #now let's do presentation\\n #TODO -- incorporate pandas tables...do only minimal work on it until then\\n\\n pnl_lines = []\\n\\n if period == \\\"YEARLY\\\":\\n\\n report_start_date = datetime(earliest_date.year,1,1)\\n report_end_date = datetime(latest_date.year,12,31)\\n\\n period_start_dates = list(rrule(YEARLY, bymonth=1, bymonthday=1,\\n dtstart=report_start_date,\\n until=report_end_date))\\n\\n period_end_dates = list(rrule(YEARLY, bymonth=12, bymonthday=-1,\\n dtstart=report_start_date,\\n until=report_end_date))\\n\\n elif period == \\\"MONTHLY\\\":\\n\\n report_start_date = datetime(earliest_date.year,\\n earliest_date.month,\\n 1)\\n report_end_date = datetime(latest_date.year,\\n latest_date.month,\\n calendar.monthrange(latest_date.year,\\n latest_date.month)[1])\\n\\n period_start_dates = list(rrule(MONTHLY, bymonthday=1,\\n dtstart=report_start_date,\\n until=report_end_date))\\n\\n period_end_dates = list(rrule(YEARLY, bymonthday=-1,\\n dtstart=report_start_date,\\n until=report_end_date)) \\n\\n header_1 = [\\\"\\\", \\\"Period Start -->\\\"] + period_start_dates\\n header_2 = [\\\"Account\\\", \\\"Period End -->\\\"] + period_end_dates\\n\\n pnl_lines.append(header_1)\\n pnl_lines.append(header_2)\\n\\n \\\"\\\"\\\"Clearly, there's a way to do this with only one pass of the data...\\n let's get that right in the first re-write...probably with pandas\\\"\\\"\\\"\\n\\n #now let's fill up the pnl_lines with what we know to be the relevant data\\n #for now, we'll rely on the knowledge that the data is coming to us in\\n #date order, but that should be fixed too...\\n\\n for account in relevant_activity:\\n\\n account_row = [account, \\\"\\\"] #one value per period \\n\\n current_period_index = 0 #primitive counter, yes!\\n this_period_total = 0 #this will be this period's total\\n\\n for line in relevant_activity[account]:\\n \\n line_amount = line[amount_i]\\n line_date = line[date_i] \\n\\n if line_date > period_end_dates[current_period_index]:\\n\\n account_row.append(this_period_total)\\n this_period_total = line_amount\\n current_period_index +=1\\n\\n else:\\n \\n this_period_total = round(this_period_total +\\n line_amount, 2)\\n\\n \\\"\\\"\\\"super sloppy...\\\"\\\"\\\"\\n account_row.append(this_period_total) #for the last period\\n current_period_index +=1\\n\\n while current_period_index < len(period_end_dates):\\n account_row.append(0)\\n current_period_index +=1\\n\\n pnl_lines.append(account_row)\\n\\n return pnl_lines\",\n \"def period(self):\\n return f\\\"{self.measurement_date.year}/{self.measurement_date.month}\\\"\",\n \"def quantaHandledByPeriod(self, period):\\n\\n start_datetime = self.start_time.to_python_datetime()\\n end_datetime = self.end_time.to_python_datetime()\\n\\n total_quanta = 0\\n\\n # Iterate through the quanta of the period, while the starting_quanta is less\\n # than the ending quanta\\n\\n quanta_start_time = period.start_time\\n while quanta_start_time < period.end_time:\\n quanta_end_time = quanta_start_time + timedelta(minutes=granularity_in_minutes())\\n\\n if start_datetime <= quanta_start_time < end_datetime:\\n if start_datetime < quanta_end_time <= end_datetime:\\n total_quanta = total_quanta + 1\\n\\n quanta_start_time = quanta_start_time + timedelta(minutes=granularity_in_minutes())\\n\\n return total_quanta\",\n \"def limit_date_range_from(self):\\n return self._limit_date_range_from\",\n \"def determine_periods(obj):\\n return obj[len(obj)-1][\\\"period\\\"]\",\n \"def grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"grace_period\\\")\",\n \"def grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"grace_period\\\")\",\n \"def grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"grace_period\\\")\",\n \"def grace_period(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"grace_period\\\")\",\n \"def current_quarter_end(start_year:int, start_month:int, logger:lg.Logger = None) -> date:\\n if logger:\\n logger.info(F\\\"start year = {start_year}; start month = {start_month}\\\")\\n end_year, end_month = next_quarter_start(start_year, start_month)\\n # end date is one day back from the start of the next period\\n return date(end_year, end_month, 1) - ONE_DAY\",\n \"def last(self) -> 'outputs.CommitmentPeriodResponse':\\n return pulumi.get(self, \\\"last\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84471315","0.8381506","0.68428826","0.6510184","0.6339413","0.60962486","0.60355204","0.6016154","0.6016154","0.6016154","0.6016154","0.6016154","0.6016154","0.6016154","0.6016154","0.6013164","0.5948316","0.58576053","0.58273315","0.58267355","0.572815","0.5672116","0.5642098","0.5618393","0.56165165","0.549865","0.54842216","0.5463866","0.5452018","0.544054","0.540237","0.53940475","0.5384737","0.53807724","0.536973","0.53555244","0.53511566","0.5345926","0.5345926","0.5345926","0.5345926","0.5345926","0.5345926","0.5345926","0.5345926","0.5345926","0.5345926","0.5345926","0.5345926","0.53408724","0.5314138","0.5302331","0.52880704","0.52830076","0.52730215","0.52422166","0.52128017","0.5212548","0.521189","0.5178269","0.51723397","0.5168015","0.5166653","0.5156847","0.5150747","0.5137372","0.5122274","0.5120129","0.5113371","0.5078736","0.50711745","0.5070952","0.5065349","0.5038819","0.50291747","0.50278246","0.50227565","0.5016887","0.5011094","0.50102353","0.49985716","0.49718535","0.49652025","0.4963701","0.49523288","0.49407074","0.49304017","0.49261263","0.49230066","0.492173","0.49210066","0.4920434","0.49172437","0.48874632","0.48860762","0.48860762","0.48860762","0.48860762","0.4880182","0.48799425"],"string":"[\n \"0.84471315\",\n \"0.8381506\",\n \"0.68428826\",\n \"0.6510184\",\n \"0.6339413\",\n \"0.60962486\",\n \"0.60355204\",\n \"0.6016154\",\n \"0.6016154\",\n \"0.6016154\",\n \"0.6016154\",\n \"0.6016154\",\n \"0.6016154\",\n \"0.6016154\",\n \"0.6016154\",\n \"0.6013164\",\n \"0.5948316\",\n \"0.58576053\",\n \"0.58273315\",\n \"0.58267355\",\n \"0.572815\",\n \"0.5672116\",\n \"0.5642098\",\n \"0.5618393\",\n \"0.56165165\",\n \"0.549865\",\n \"0.54842216\",\n \"0.5463866\",\n \"0.5452018\",\n \"0.544054\",\n \"0.540237\",\n \"0.53940475\",\n \"0.5384737\",\n \"0.53807724\",\n \"0.536973\",\n \"0.53555244\",\n \"0.53511566\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.5345926\",\n \"0.53408724\",\n \"0.5314138\",\n \"0.5302331\",\n \"0.52880704\",\n \"0.52830076\",\n \"0.52730215\",\n \"0.52422166\",\n \"0.52128017\",\n \"0.5212548\",\n \"0.521189\",\n \"0.5178269\",\n \"0.51723397\",\n \"0.5168015\",\n \"0.5166653\",\n \"0.5156847\",\n \"0.5150747\",\n \"0.5137372\",\n \"0.5122274\",\n \"0.5120129\",\n \"0.5113371\",\n \"0.5078736\",\n \"0.50711745\",\n \"0.5070952\",\n \"0.5065349\",\n \"0.5038819\",\n \"0.50291747\",\n \"0.50278246\",\n \"0.50227565\",\n \"0.5016887\",\n \"0.5011094\",\n \"0.50102353\",\n \"0.49985716\",\n \"0.49718535\",\n \"0.49652025\",\n \"0.4963701\",\n \"0.49523288\",\n \"0.49407074\",\n \"0.49304017\",\n \"0.49261263\",\n \"0.49230066\",\n \"0.492173\",\n \"0.49210066\",\n \"0.4920434\",\n \"0.49172437\",\n \"0.48874632\",\n \"0.48860762\",\n \"0.48860762\",\n \"0.48860762\",\n \"0.48860762\",\n \"0.4880182\",\n \"0.48799425\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63429344"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":3199,"cells":{"query":{"kind":"string","value":"Transform mp3 file into wav format calling bash and using mpg123 or ffmpeg."},"document":{"kind":"string","value":"def mp3_to_wav(mp3_file, wav_file, encoder='mpg123'):\n if encoder == 'mpg123':\n bash_command = ['mpg123', '-w', wav_file, '--mono', mp3_file]\n else:\n bash_command = ['ffmpeg', '-i', mp3_file, wav_file]\n subprocess.run(bash_command)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def mp3_to_wav(show_progress=True):\n\n # Define a devnull var to supress subprocess output\n devnull = open(os.devnull, 'w')\n\n # Get a list of the filepath for each of the mp3 files in each subdirectory of data/fma_small\n file_list = glob.glob('./../data/fma_small/*/*.mp3')\n\n # Get the number of files N and initialize a counter\n N = len(file_list)\n counter = 0\n\n # For each file/filepath, convert that file to wav format and save it to data/wavs/*/*.wav (so as a wave file)\n for filepath in file_list:\n\n # Every 100 file conversions, print a progress update\n if counter % 50 == 49 and show_progress:\n progress = str(round(100 * counter / N, 2))\n print('File conversion ' + progress + '% complete.')\n\n # Get the file name from the path and define a new path for the wav file\n file_name = filepath[24:-4]\n new_path = './../data/wavs/' + file_name + '.wav'\n\n # Call the subprocess using ffmpeg to convert the file to wav format (and supress all the output)\n subprocess.call(['ffmpeg', '-i', filepath, new_path], stdout=devnull)\n\n # Increment the counter\n counter += 1","def convert_to_wav(mp3_filename):\n\n wav_filename = mp3_filename[:-4] + \".wav\"\n complete_mp3FileName = os.path.join(MP3_FOLDER, mp3_filename)\n complete_wavFileName = os.path.join(WAV_FOLDER, wav_filename)\n\n mp3_file = AudioSegment.from_mp3(complete_mp3FileName)\n mp3_file.export(complete_wavFileName, format=\"wav\")\n\n print(f\"The mp3 file {complete_mp3FileName} was successfully converted to \" \\\n + f\"the wav file {complete_wavFileName}.\")","def convert_to_mp3(self,path, filename):\n\n codec = \"libmp3lame\"\n mp3_filename = filename + \".mp3\"\n\n command = [self.FFMPEG_BIN,\n \"-n\",\n \"-i\", path,\n \"-acodec\", codec,\n \"-ab\", \"128k\",\n mp3_filename\n ]\n\n return command","def convert_to_wav(fin, fout):\n temp = subprocess.run([\"ffmpeg\",\n \"-i\", \n fin, \n fout], \n stdout=subprocess.PIPE, \n stderr=subprocess.PIPE)","def extract_audio_from(file, out_dir=''):\n output_filename = f'{os.path.join(out_dir, os.path.basename(file)[:-4])}.wav'\n os.system(f'ffmpeg -i {file} {output_filename}')\n return output_filename","def analyze_mp3(mp3filespec):\n \n # Make a temporary working directory for storing the wav file\n # that soundstretch should analyze\n wavfilespec = tempfile.NamedTemporaryFile(suffix='.wav') \n \n # Use lame to make a wav representation of the mp3 file to be analyzed\n wav_command = 'sox %s %s' % (mp3filespec, wavfilespec.name)\n subprocess.call([wav_command], shell=True, stderr=open(os.devnull, 'w'))\n \n # Call soundstretch to analyze the wav file\n bpm_command = 'soundstretch %s -bpm' % wavfilespec.name\n p = subprocess.Popen([bpm_command], shell=True,stdout=subprocess.PIPE)\n output = p.communicate()[0]\n \n # Delete temporary working directory and its contents\n #shutil.rmtree(workingdir)\n\n bpm_suggestion = _get_bpm_from_soundstretch(output)\n\n return fit_bpm_in_window(bpm_suggestion)","def all_wav_to_mp3(self):\n for each_file, artist in self.past_songs_db_data:\n self.convert_wav_to_mp3(each_file)","def convert_to_mp3(filename: str, title: str, start: int=None, end: int=None) -> list:\n\t# setup args for ffmpeg\n\tfile_a = f\"{path_to_wrk_dir}{filename}.mp4\" # input file\n\tfile_b = f\"{path_to_wrk_dir}{title}.mp3\" # output file\n\tfiles_b = [] # this list need if file more than 30 mb\n\targs = [\n\t\t\"/usr/bin/ffmpeg\", # path to ffmpeg\n\t\t\"-i\", # flag for input file\n\t\tfile_a, # input file\n\t\t\"-acodec\", # setup codec\n\t\t\"libmp3lame\", # codec name\n\t\t]\n\n\t# now need setup timings for target encode\n\tif start is not None and start != 0:\n\t\targs = args + [\"-ss\", str(start)]\n\tif end is not None and end != 0:\n\t\targs = args + [\"-t\", str(end - start)]\n\n\t# and last part for args to ffmpeg\n\targs = args + [\n\t\t\"-metadata\", # setup metadata for file\n\t\tf\"title={title}\", # title\n\t\t\"-metadata\",\n\t\tf\"artist={title}\", # and artist\n\t\t\"-b:a\", # setup bitrate\n\t\t\"320k\", # setup max bitrate\n\t\tfile_b,\n\t\t]\n\tprint(f\"{args}\")\n\t# start subprocess for encoding\n\tpopen = subprocess.Popen(args)\n\tpopen.wait()\n\n\t# check size file. if he more than 30 mb, bot need split him to chunks.\n\tsize = getsize(file_b) / 1024 / 1024\n\tif size > 30 and ( start or end is None ):\n\t\t# setup args for split to chunks\n\t\targs = [\n\t\t\t\"ffprobe\",\n\t\t\t\"-show_entries\",\n\t\t\t\"format=duration\",\n\t\t\t\"-i\",\n\t\t\tfile_b,\n\t\t\t]\n\n\t\t# get duration video.\n\t\tpopen = subprocess.Popen(args, stdout=subprocess.PIPE)\n\t\tpopen.wait()\n\t\toutput = popen.stdout.read()\n\t\t# now we know how long this audio file\n\t\t# split to 10 min chunks\n\t\tdur = re.findall(r\"\\d{1,10}\", str(output))\n\t\t# get chunks count for loop\n\t\tcount_chunks = (int(dur[0]) // 600) + 1\n\t\tfor chunk_start_time in range(0, count_chunks):\n\t\t\t# setup args for split\n\t\t\t# big parts of args the same for encode\n\t\t\targs = [\n\t\t\t\t\"/usr/bin/ffmpeg\",\n\t\t\t\t\"-i\",\n\t\t\t\tfile_b,\n\t\t\t\t\"-ss\",\n\t\t\t\tf\"{chunk_start_time * 600}\", # when start chunk\n\t\t\t\t\"-t\",\n\t\t\t\t\"600\", # 10 mints duration\n\t\t\t\t\"-acodec\",\n\t\t\t\t\"copy\", # copy\n\t\t\t\t\"-b:a\",\n\t\t\t\t\"320k\",\n\t\t\t\tf\"{path_to_wrk_dir}{title}_{chunk_start_time}.mp3\", # now we have path to video with chunk number.\n\t\t\t]\n\t\t\ttry:\n\t\t\t\t# start process for cut chunk\n\t\t\t\tpopen = subprocess.Popen(args, stdout=subprocess.PIPE)\n\t\t\t\tpopen.wait()\n\t\t\t# handle except.\n\t\t\texcept Exception as e:\n\t\t\t\tprint(f\"Exception - {e}\")\n\t\t\tfiles_b.append(f\"{path_to_wrk_dir}{title}_{chunk_start_time}.mp3\") # append name of file in list\n\t\tremove(file_b)\n\ttry:\n\t\t# remove tmp file\n\t\tremove(file_a)\n\t# handle except\n\texcept FileNotFoundError:\n\t\tfiles = get_file_list(path_to_wrk_dir)\n\t\tfor i in files:\n\t\t\tif -1 != f\"{path_to_wrk_dir}{i}\".find(f\"{filename}\") and f\"{i}\".find(f\".mp3\") == -1:\n\t\t\t\ttry:\n\t\t\t\t\tremove(f\"{path_to_wrk_dir}{i}\")\n\t\t\t\texcept FileNotFoundError:\n\t\t\t\t\tprint(f\"can't remove file {path_to_wrk_dir}{i}\")\n\tif len(files_b) == 0:\n\t\treturn [file_b]\n\telse:\n\t\treturn files_b","def extract_audio(file_name, audio_directory):\n basename = os.path.splitext(os.path.basename(file_name))[0]\n audio_file_name = audio_directory + '/' + basename + '.wav'\n subprocess.call(['ffmpeg', '-y', '-i', file_name, '-ac', '1', audio_file_name])\n return audio_file_name","def mp3_to_wav(song_dir, snip_dir, bird_list_path='bird_list.txt'):\n if os.path.exists(snip_dir):\n shutil.rmtree(snip_dir)\n os.makedirs(snip_dir)\n with open(bird_list_path) as f:\n lines = f.readlines()\n bird_list = [line.rstrip('\\n') for line in lines]\n # Build the bird-labeled subdirectories in 'snip_dir'.\n _make_bird_dirs(snip_dir, birds_list)\n # Populate the subdirectory with recordings converted from .mp3 to .wav.\n for f in os.listdir(song_dir):\n bird = extract_bird_name(f)\n if bird in birds_list:\n index = birds_list.index(bird)\n wav_filename = os.path.splitext(f)[0].replace(' ', '_') + '.wav'\n orig = os.path.join(mp3_dir, f)\n new = os.path.join(snip_dir, str(index), wav_filename)\n # MP3-to-WAV conversion requires the ffmpeg package.\n call([\"ffmpeg\", \"-i\", orig, new])","def process_sound_file(file_path):\n\n return to_mfcc(get_wav(file_path))","def convert_mp3_to_ogg(self, filename: str):\n mp3_path = os.path.join(self.directory, filename)\n ogg_path = mp3_path.replace(self.extension_mp3, self.extension_ogg)\n if os.path.isfile(ogg_path):\n # already done\n return\n command = [FFMPEG_BIN, '-i', mp3_path, ogg_path]\n pipe = sp.Popen(command, shell=False, stdout=sp.PIPE)\n pipe.wait()","def convert_to_wav (filename, name, origpath, wavpath, mono):\n print(\"Converting {0} to .wav...\".format(filename))\n if not re.match(r\".*_\\d+$\",name):\n # If filenames do include video titles\n name = name.rsplit('_',1)[0]\n\n channel, vid_num = name.rsplit('_', 1)\n channel = re.sub(r'[^A-Za-z1-9]', '', channel)\n newname = '_'.join([channel, vid_num])\n\n exportname = newname + \".wav\"\n filepath = path.join(origpath, filename)\n\n if not path.exists(wavpath):\n makedirs(wavpath)\n exportPath = path.join(wavpath, exportname)\n sound = AudioSegment.from_file(filepath,\"mp4\")\n if mono == True:\n sound = sound.set_channels(1)\n sound.export(exportPath, format=\"wav\")","def to_voice(item):\r\n item.seek(0)\r\n item = AudioSegment.from_file(item)\r\n m = io.BytesIO()\r\n m.name = \"voice.ogg\"\r\n item.split_to_mono()\r\n dur = len(item) / 1000\r\n item.export(m, format=\"ogg\", bitrate=\"64k\", codec=\"libopus\")\r\n m.seek(0)\r\n return m, dur","def play_audio():\n directory = os.fsencode(MINI_PATH)\n print(directory)\n adp= []\n # lst = os.listdir(directory)\n # lst.sort()\n for file in os.listdir(directory):\n filename = os.fsdecode(file)\n #print(file)\n\n if filename.endswith(\".mp3\"): \n adp.append(MINI_PATH+filename)\n #print(adp)\n adp.sort()\n print(\"ADP: \", adp)\n x = \"|\".join(adp)\n print( f'concat:{x}')\n subprocess.call(['ffmpeg', '-i', f'concat:{x}', '-acodec', 'copy', RESULT_PATH])\n \n for file in os.listdir(directory):\n filename = os.fsdecode(file)\n print(filename)\n if filename.endswith(\".mp3\"):\n os.remove(MINI_PATH+filename)","def mp3ogg(fname, datas):\n oggname = \"%s.ogg\" % fname[:-4]\n logger.info(\"(mp3ogg) encode [%s]\" % fname)\n logger.debug(\"(mp3ogg) oggenc binary path %s\" % settings.OGGENC)\n logger.debug(\"(mp3ogg) mpg123 binary path %s\" % settings.MPG123)\n\n command = [settings.OGGENC,\n \"--artist\", datas['artist'],\n \"--title\", datas['title'],\n \"--album\", datas['album'],\n \"--genre\", datas['genre'],\n \"--date\", datas['date'],\n \"--tracknum\", datas['tracknumber'],\n \"-o\", oggname,\n \"-\"]\n\n try:\n mpg = subprocess.Popen([settings.MPG123,\n \"-w\",\n \"-\",\n fname],\n stdout=subprocess.PIPE)\n\n ogg = subprocess.Popen(command,\n stdin=mpg.stdout, # pylint: disable-msg=E1101\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n (stdout, stderr) = ogg.communicate()\n logger.debug(stdout)\n logger.error(stderr)\n result = oggname\n except:\n logger.error(\"(mp3ogg) subprocess failed on [%s]\" % fname)\n result = None\n\n if result:\n os.unlink(fname)\n\n return result","def main():\n destination = Path(argv[1])\n source_files = destination.glob(\"**/*.wma\")\n for file in source_files:\n new_name = file.name.rsplit(\".\", maxsplit=1)[0] + \".flac\"\n dest = str(file.parent / new_name)\n cmd = list(map(str, [\"avconv\", \"-i\", file, dest]))\n if platform == \"win32\":\n print(\"Running on windows... on Unix I'd run the following command:\")\n print(cmd)\n else:\n that = Popen(cmd)\n that.wait()","def convert_to_wav(txt_file, sph_path, target_dir):\n wav_dir = os.path.join(target_dir, 'wav/')\n txt_dir = os.path.join(target_dir, 'txt/')\n os.makedirs(wav_dir, exist_ok=True)\n os.makedirs(txt_dir, exist_ok=True)\n path_to_data = os.path.dirname(txt_file)\n\n def process(x):\n file_path = x[\"audio_file\"]\n text = x[\"transcription\"]\n start_time = x[\"start_time\"]\n duration = x[\"end_time\"] - start_time\n file_name = os.path.splitext(os.path.basename(file_path))[0]\n file_name = str(start_time) + \"_\" + str(duration) + file_name\n text = text.strip().upper()\n with open(os.path.join(txt_dir, file_name + '.txt'), 'w') as f:\n f.write(text)\n cmd = \"sox -v 0.6 -t wav {} -r {} -b 16 -c 1 -t wav {} trim {} {}\".format(\n os.path.join(path_to_data, file_path),\n args.sample_rate,\n os.path.join(wav_dir, file_name + \".wav\"),\n start_time,\n duration)\n subprocess.call([cmd], shell=True)\n print('Converting wav to wav for {}.'.format(txt_file))\n # generate processed data\n data = read_transcription_file(txt_file, sph_path)\n with ThreadPool(10) as pool:\n pool.map(process, data)","def check_wav(song, source_folder, temp_folder, encoder='mpg123'):\n # Name of files\n song_name, extension = os.path.splitext(song)\n mp3_file = os.path.join(source_folder, song)\n if '.wav' != extension:\n wav_file = os.path.join(temp_folder, song_name + '.wav')\n try:\n if not os.path.isfile(wav_file):\n mp3_to_wav(\n mp3_file=mp3_file,\n wav_file=wav_file,\n encoder=encoder)\n else:\n pass\n except MemoryError:\n logger.error('MemoryError: %s MP3 couldn\\'t be transformed into WAV', song_name)\n else: # Already a wav file\n copyfile(mp3_file, os.path.join(temp_folder, song_name))","def convert(\n album,\n):\n for track in list_dir(album):\n ext = splitext(track)[1]\n if ext != \".mp3\":\n new_track = track.replace(ext, \".mp3\")\n if not exists(new_track):\n track_non_mp3 = AudioSegment.from_file(track, format=ext[1:])\n print(f\"{track} -> {new_track}\")\n track_non_mp3.export(new_track, format=\"mp3\")\n os.remove(track)","def play_audio(filename):\n os.system(AUDIOPLAYER + ' ' + filename)","def mono(filename,wout=True):\n n, data, data_dB,sr,ch=inputwav(filename)\n if ch==2:\n print('Converting to mono...')\n L=data[:,0]\n R=data[:,1]\n n=len(data)\n data_m=np.zeros((n,1))\n data_m=L/2.0+R/2.0\n if wout==True:\n print('Exporting...')\n sf.write(filename[0:len(filename)-4]+'_mono.wav',data_m,sr,'PCM_16')\n print('Done!')\n return data_m\n else:\n print( \"Error: input is already mono stoooooooooopid!\")","def wavplay(filename):\n\tif (os.path.isfile(filename) == False): # raise error if wrong input file\n\t\tprint(\"Input file does not exist. Make sure you computed the analysis/synthesis\")\n\telse:\n\t\tif sys.platform == \"linux\" or sys.platform == \"linux2\":\n\t\t # linux\n\t\t subprocess.call([\"aplay\", filename])\n\n\t\telif sys.platform == \"darwin\":\n\t\t\t# OS X\n\t\t\tsubprocess.call([\"afplay\", filename])\n\t\telse:\n\t\t\tprint(\"Platform not recognized\")","def main(directory, wavelength=16000, replace=True):\n\n if os.path.isdir(directory):\n # get the directory of mp3 files\n mpthree_files = find_directory__files(directory, 'mp3')\n\n # check whether there are mp3 files\n if len(mpthree_files) > 0:\n # converts all the mp3 files to wav files\n map(lambda x: convert_mp3_to_wav(x, replace=replace), mpthree_files.values())\n\n # now get the wav files after conversion(if any)\n wav_files = find_directory__files(directory, 'wav')\n\n # convert\n map(lambda x: convert_wavelength_file(x, wavelength=wavelength, replace=replace), wav_files.values())\n elif os.path.isfile(directory):\n\n # check if it's a wav\n filetype = find_filetype(directory)\n if filetype != 'wav':\n if filetype == 'mp3':\n convert_mp3_to_wav(directory, replace=replace)\n # get the new file name\n directory = directory.replace('mp3', 'wav')\n else:\n raise ValueError(\"Not a supported filetype at this moment\")\n\n # when filetype == wav or after converting from mp3 to wav\n convert_wavelength_file(directory, wavelength, replace=replace)\n else:\n raise ValueError(\"input is wrong\")","def to_audio(self, _in, _out, bitrate, file_format):\n\n # Default output parameter\n # If not current directory, append '/'\n if os.path.isdir(_out):\n _out = '' if _out == '.' else _out + '/'\n _out += self.get_name_from_path(_in,\n replace=True) + '.' + file_format\n _out = _out.replace('//', '/')\n self.out = _out\n\n # File format unchecked for single inputs\n if not check_is_video(_in):\n msg = \" is not a supported media type\"\n self.abort_conversion(\n self.get_name_from_path(_in) + msg)\n\n \"\"\"\n else:\n base_name = os.path.basename(_out)\n ext = os.path.splitext(base_name)[1]\n _out = _out.replace(ext, '.mp3')\n \"\"\"\n commands = ['ffmpeg', '-i', _in,\n '-vn', '-ar', '44100',\n '-ac', '2', '-ab',\n bitrate, _out]\n try:\n self.run_convert_commands(commands)\n except FileNotFoundError as er:\n res = require_ffmepg()\n\n if not res:\n self.abort_conversion(\"Dependecy not installed.\")","def encodeMP3(self, wavf: str, dstf: str, cover: str, meta: TrackMeta) -> None:\n FNULL = open(os.devnull, 'w')\n subprocess.call(['lame', '-V2', wavf, dstf], stdout=FNULL, stderr=FNULL)\n FNULL.close()\n # tag MP3\n mm = TrackMeta(meta)\n mp3 = MP3(dstf, ID3=ID3)\n mp3[\"TIT2\"] = TIT2(encoding=3, text=mm.title())\n mp3[\"TPE1\"] = TPE1(encoding=3, text=mm.artist())\n mp3[\"TALB\"] = TALB(encoding=3, text=mm.album())\n mp3[\"TPE2\"] = TPE2(encoding=3, text=mm.albumartist())\n if mm.date():\n mp3[\"TDRC\"] = TDRC(encoding=3, text=mm.date())\n mp3[\"TRCK\"] = TRCK(encoding=3,\n text=mm.tracknumber() + \"/\" + mm.tracktotal())\n mp3[\"TPOS\"] = TPOS(encoding=3,\n text=mm.discnumber() + \"/\" + mm.disctotal())\n\n # composer\n if mm.composer():\n mp3[\"TCM\"] = TCM(encoding=3, text=mm.composer())\n\n # cover\n if cover:\n data = open(cover, 'rb').read()\n if cover.endswith('png'):\n mime = 'image/png'\n else:\n mime = 'image/jpeg'\n mp3.tags.add(APIC(encoding=3, mime=mime, type=3, desc=u'Cover', data=data))\n\n # save\n mp3.save()","def transcodetomp4(file_in, logger):\n\n import subprocess\n\n file_out = file_in.replace('.mkv', '.mp4')\n\n if os.path.isfile('/usr/bin/avconv'):\n\n convert_command = 'su securityspy -c \\\"/usr/bin/avconv -i \"{}\" -f mp4 -vcodec copy -acodec '.format(file_in) + \\\n 'libfaac -b:a 112k -ac 2 -y \"{}\"'.format(file_out) + \"\\\"\"\n\n try:\n subprocess.check_call(convert_command, shell=True)\n except subprocess.CalledProcessError:\n logger.error(\"The command to transcode: {} --- failed...\".format(convert_command))\n return file_in\n\n return file_out\n else:\n return file_in\n # fin","def audio_pipeline(wav):\n sig = sb.dataio.dataio.read_audio(wav)\n return sig","def audio_pipeline(wav):\n sig = sb.dataio.dataio.read_audio(wav)\n return sig","def read_audio(f, downmix):\n if f.endswith('.mp3'):\n f = _mp3_hook(f)\n sr, audio = scipy.io.wavfile.read(f)\n if not audio.dtype is np.float32:\n audio = _normalize_pcm(audio)\n if downmix and len(audio.shape) == 2:\n audio = down_mix(audio)\n return sr, audio","def mpg_convert(input_path: str, output_path: str, check=True,\n verbose_level=0):\n if verbose_level > 0:\n v = '-v'\n else:\n v = '-q'\n os.system('mpg123 ' + v + ' -w ' + output_path + ' ' + input_path)\n if check:\n if not os.path.isfile(output_path):\n raise RuntimeError('Not able to convert file', input_path,\n output_path)","def wav_wav(orig, dest, **_kwargs):\n\n # options = kwargs.get(\"tree\").cmd_options.get(\"options\", [])\n\n # first demux it to 16 bit 48khz\n dest_list = []\n for index, orig_elem in enumerate(tools.get_iter(orig)):\n tmp_dest = os.path.join(\n os.path.dirname(dest),\n \"{0}_{1}\".format(index, os.path.basename(dest)))\n cmd = \"ffmpeg -i {orig} -acodec pcm_s16le -ar 48000 {dest}\".format(\n dest=tmp_dest,\n orig=orig_elem)\n logger.debug(cmd)\n try:\n subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)\n except subprocess.CalledProcessError as error:\n logger.error(error)\n logger.error(tools.to_unicode(error.output))\n continue\n dest_list.append(tmp_dest)\n\n if len(dest_list) > 1:\n cmd = \"sox {orig} {dest}\".format(\n orig=\" \".join(orig),\n dest=dest)\n logger.debug(cmd)\n try:\n subprocess.check_call(cmd, shell=True)\n except subprocess.CalledProcessError as error:\n logger.error(error)\n logger.error(tools.to_unicode(error.output))\n else:\n os.rename(dest_list[0], dest)\n return dest","def make_wav(text, speed=1.0, emotion='normal', output_file='__temp.wav', output_dir=os.getcwd()):\n open_jtalk = [OPENJTALK_BINPATH + '/open_jtalk']\n mech = ['-x', OPENJTALK_DICPATH]\n htsvoice = ['-m', OPENJTALK_VOICEPATH.format(emotion=emotion)]\n speed = ['-r', str(speed)]\n outwav = ['-ow', os.path.join(output_dir, output_file)]\n cmd = open_jtalk + mech + htsvoice + speed + outwav\n c = subprocess.Popen(cmd,stdin=subprocess.PIPE)\n c.stdin.write(text.encode('utf-8'))\n c.stdin.close()\n c.wait()\n return os.path.join(output_dir, output_file)","def convert(self):\n #lame --mp3input --silent -h -b BITRATE SOURCE TARGET\n self.success = False\n command = ['lame', '-h', '--silent']\n command.append('-b ' + str(self.bitrate))\n command.append(self.source)\n command.append(self.target)\n msg('command', command)\n error = check_call(command)\n if error != 0:\n raise TaskError(subprocess.CalledProcessError)\n self.success = True","def _to_wav(self):\n self._status = 0\n fname = fm.file2wav(self.get_filename()) \n if fname != self.get_filename(): # can change the name\n self._set_filename(fname) # in case of wave transcoding\n self._status = 1","def convert_wav(src_wav, dst_wav, subtype='PCM_16'):\n assert os.path.exists(src_wav), \"{} not exists!\".format(src_wav)\n data, sr = soundfile.read(src_wav)\n soundfile.write(dst_wav, data, sr, subtype=subtype)","def get_audio(name, n):\n audio_path = os.path.join(args.input_folder, name, \"audio.ogg\")\n if not os.path.exists(audio_path):\n ## Some folders have multiple .ogg files, so we need to first combine them into one file. Example:\n ## |── Universe\n ## │ ├── aligned.swc\n ## │ ├── audio1.ogg\n ## │ ├── audio2.ogg\n ## │ ├── audio3.ogg\n ## │ ├── audio4.ogg\n ## │ ├── audiometa.txt\n ## │ ├── info.json\n ## │ ├── wiki.html\n ## │ ├── wiki.txt\n ## │ └── wiki.xml\n\n multiple_ogg_files = []\n for i in range(1, 5):\n path = os.path.join(args.input_folder, name, \"audio\" + str(i) + \".ogg\")\n if os.path.exists(path):\n multiple_ogg_files.append(path)\n else:\n break\n if len(multiple_ogg_files) == 0:\n return\n elif len(multiple_ogg_files) == 1:\n os.system(\"cp \\\"\" + multiple_ogg_files[0] + \"\\\" \\\"\" + audio_path + \"\\\"\")\n else:\n tmp_file_name = \"ffmeg_inputs.txt\"\n print(\"tmp_file_name=\", tmp_file_name)\n with open(tmp_file_name, \"w\", encoding=\"utf-8\") as tmp_file:\n for path in multiple_ogg_files:\n tmp_file.write(\"file '\" + path + \"'\\n\")\n cmd = \"ffmpeg -f concat -i \\\"\" + tmp_file_name + \"\\\" -c copy \\\"\" + audio_path + \"\\\"\"\n print(cmd)\n os.system(cmd)\n\n output_audio_path = args.destination_folder + \"/audio/\" + str(n) + \".ogg\"\n os.system(\"cp \\\"\" + audio_path + \"\\\" \" + output_audio_path)","def create_audio_file():\n # Get the response from boto3\n raw_audio = generate_audio()\n # pull the Audiostream object from the response from boto3\n raw_audio = raw_audio[\"AudioStream\"]\n # create output location\n # process the whole block\n with closing(raw_audio) as audio:\n with open(\"output_audio.mp3\", \"wb\") as file:\n file.write(raw_audio.read())","def play_sound():\r\n try:\r\n\r\n file_name = r\"sound.mp3\"\r\n playsound.playsound(file_name)\r\n except OSError:\r\n AudioSegment.converter=r\"/Users/russelllamb/Downloads/ffmpeg\"\r\n sound=AudioSegment.from_mp3(r\"sound.mp3\")\r\n play(sound)","def generate_audio():\n text, lang = introduction()\n ses = boto3.Session(profile_name=\"default\")\n pol = ses.client(\"polly\")\n res = pol.synthesize_speech(Text=text, LanguageCode=lang, OutputFormat=\"mp3\", VoiceId=VOICE)\n return res","def convert(file):\n extension = file[-4:]\n if extension == '.wav':\n return file\n if not exists(file):\n raise IOError('%s file not found' % file)\n if not extension in SUPPORTED_EXTENSION:\n raise IOError('%s file format is not supported' % file)\n if not exists(CONVERTION_DIRECTORY):\n makedirs(CONVERTION_DIRECTORY)\n filename = splitext(basename(file))[0]\n path = join(CONVERTION_DIRECTORY, filename + '.wav')\n if (not exists(path)):\n logging.info(\"Converting file %s\" % file)\n CONVERTERS[extension](file).export(path, format='wav')\n return path","def extract(path, quality=\"medium\"):\n\n try:\n file = ffmpeg.input(path)\n output_path = path[:-3] + \"ogg\"\n if os.path.exists(output_path):\n print(\n f\"[{colored('#','yellow')}] Audio file {colored(path2title(output_path),'green')} already exists\"\n )\n return output_path\n print(\n f\"\\n[{colored('+','green')}] Extracting audio for file %s\"\n % (colored(path2title(path), \"green\")),\n end=\"\",\n )\n from util import Animation\n\n anim = Animation()\n file.audio.output(\n output_path,\n acodec=\"libvorbis\",\n audio_bitrate=BITRATE * get_multiplier(quality),\n loglevel=0,\n ).run()\n anim.complete()\n print(\n f\"[{colored('+','green')}] Extraction completed for file %s\"\n % (colored(path2title(output_path), \"green\"))\n )\n\n except Exception as ex:\n print(\n f\"[{colored('-','red')}] There was an error extracting the audio for path {colored(path2title(output_path),'green')}: \",\n ex,\n )\n sys.exit(-1)\n\n return output_path","def get_large_audio_transcription(path):\n # open the audio file using pydub\n r = sr.Recognizer()\n sound = AudioSegment.from_mp3(path)\n sound.export(\"tmp.wav\", format=\"wav\")\n sound = AudioSegment.from_wav('tmp.wav')\n # split audio sound where silence is 700 miliseconds or more and get chunks\n chunks = split_on_silence(sound,\n # experiment with this value for your target audio file\n min_silence_len = 500,\n # adjust this per requirement\n silence_thresh = sound.dBFS-14,\n # keep the silence for 1 second, adjustable as well\n keep_silence=500,\n )\n folder_name = \"audio-chunks\"\n # create a directory to store the audio chunks\n if not os.path.isdir(folder_name):\n os.mkdir(folder_name)\n whole_text = \"\"\n\n chapter=(str(path.split('/')[-1])).split('_')[3]\n # if chapter == '01':\n # target=2\n # else:\n # target=1\n target=2\n # process each chunk\n for i, audio_chunk in enumerate(chunks, start=1):\n # export audio chunk and save it in\n # the `folder_name` directory.\n if i==1:\n chunk_filename = os.path.join(folder_name, f\"chunk{i}.wav\")\n audio_chunk.export(chunk_filename, format=\"wav\")\n # recognize the chunk\n with sr.AudioFile(chunk_filename) as source:\n audio_listened = r.record(source)\n # try converting it to text\n try:\n text = r.recognize_google(audio_listened,language=\"en-US\")\n\n except sr.UnknownValueError as e:\n print(\"Error:\", str(e))\n else:\n #text = f\"{text.capitalize()}. \"\n #print(chunk_filename, \":\", text)\n whole_text += text\n # return the text for all chunks detected\n else:\n chunk_filename = os.path.join(folder_name, f\"chunk{i}.wav\")\n audio_chunk.export(chunk_filename, format=\"wav\")\n # recognize the chunk\n with sr.AudioFile(chunk_filename) as source:\n audio_listened = r.record(source)\n # try converting it to text\n try:\n text = r.recognize_google(audio_listened, language=\"en-US\")\n\n except sr.UnknownValueError as e:\n print(\"Error:\", str(e))\n else:\n #text = f\"{text.capitalize()}. \"\n # print(chunk_filename, \":\", text)\n if chapter == '01':\n whole_text += ' ' +text\n if str(text).isalnum():\n if str(text).split(' ')[0]==' ':\n whole_text += text\n else: whole_text += ' '+text\n # return the text for all chunks detected\n\n if i==target:\n break\n if os.path.isfile('tmp.wav') :os.remove('tmp.wav')\n subprocess.run([\"rm\", \"-rf\", folder_name])\n return whole_text","def save_mp3(ndarray, sr, feature_name, out_path, x, y, new_labels, mp3_filename=None):\n import soundfile as sf\n\n def _save_mp3(source_path, out_path):\n cmd = [\n 'lame',\n '--preset',\n 'insane',\n str(source_path),\n str(out_path)\n ]\n errno = subprocess.call(cmd)\n if errno:\n print('{} encoding failed with code'.format(source_path), end=' ')\n print(errno)\n print('skipping...')\n return errno\n os.remove(source_path)\n return 0\n\n # this is kind-of standard\n if mp3_filename is None:\n mp3_filename = FeatureExtractor.get_file_name(x, feature_name, 'mp3')\n wav_filename = mp3_filename.replace('mp3', 'wav')\n sf.write(str(out_path / wav_filename), ndarray, sr) # write wav file\n errno = _save_mp3(out_path / wav_filename,\n out_path / mp3_filename) # load wav, encode as mp3 and remove wav file\n if errno:\n # if any error, then keep wav\n filename = wav_filename\n else:\n # non-error clause, then it was successfully exported to mp3\n filename = mp3_filename\n if new_labels is not None:\n new_labels.append([filename, y])\n print('info: {} transformed and saved!'.format(filename))\n return filename","def mp4_to_mp3(filepath):\n audio_clip = AudioFileClip(filepath)\n mp3_filename = filepath[:-3] + 'mp3'\n audio_clip.write_audiofile(mp3_filename)\n os.remove(filepath)\n audio_clip.close()","def enregistre_audio(\n audio: AudioSegment, \n chemin:str = 'animalese.wav',\n format:str ='wav'\n ) -> AudioSegment:\n\n which = pydub.utils.which\n\n if which(\"avconv\"):\n app = \"avconv\"\n elif which(\"ffmpeg\"):\n app = \"ffmpeg\"\n elif format not in {'raw', 'wav'}:\n raise FileNotFoundError(\"ffmpeg/avconv introuvable.\") \n\n return audio.export(chemin, format=format)","def create_wav_file(self, ):\n\n f_out = open(self.wav_file, 'w')\n u_utt2spk = open(self.utt2spk, 'w')\n for file in glob.glob(self.wav_folder+'/*.wav'):\n base = os.path.basename(file).split('.')[0]\n # write to scp file\n f_out.write(base + '\\t' + file + '\\n')\n u_utt2spk.write(base + '\\t' + 'tts' + '\\n')","async def transcribe_wav(args: argparse.Namespace, core: Voice2JsonCore) -> None:\n from rhasspyasr import Transcription\n\n # Make sure profile has been trained\n assert core.check_trained(), \"Not trained\"\n\n # Get speech to text transcriber for profile\n transcriber = core.get_transcriber(open_transcription=args.open, debug=args.debug)\n\n # Directory to report WAV file names relative to\n relative_dir = (\n None if args.relative_directory is None else Path(args.relative_directory)\n )\n\n try:\n if args.wav_file or args.stdin_files:\n # Read WAV file paths\n wav_files = args.wav_file\n if args.stdin_files:\n _LOGGER.debug(\"Reading file paths from stdin\")\n wav_files = itertools.chain(wav_files, sys.stdin)\n\n for wav_path_str in wav_files:\n wav_path_str = wav_path_str.strip()\n\n # Load and convert\n wav_path = Path(wav_path_str)\n _LOGGER.debug(\"Transcribing %s\", wav_path)\n\n wav_data = await core.maybe_convert_wav(wav_path.read_bytes())\n\n # Transcribe\n transcription = (\n transcriber.transcribe_wav(wav_data) or Transcription.empty()\n )\n result = dataclasses.asdict(transcription)\n\n if relative_dir is None:\n # Add name of WAV file to result\n result[\"wav_name\"] = wav_path.name\n else:\n # Make relative to some directory\n result[\"wav_name\"] = str(\n wav_path.absolute().relative_to(relative_dir.absolute())\n )\n\n print_json(result)\n else:\n # Read WAV data from stdin\n _LOGGER.debug(\"Reading WAV data from stdin\")\n\n if args.input_size:\n # Number of bytes is on separate line\n line = sys.stdin.buffer.readline().strip()\n if not line:\n return\n\n num_bytes = int(line)\n while num_bytes > 0:\n # Read in WAV\n wav_data = sys.stdin.buffer.read(num_bytes)\n while len(wav_data) < num_bytes:\n wav_data = sys.stdin.buffer.read(num_bytes - len(wav_data))\n\n # Transcribe\n wav_data = await core.maybe_convert_wav(wav_data)\n transcription = (\n transcriber.transcribe_wav(wav_data) or Transcription.empty()\n )\n result = dataclasses.asdict(transcription)\n\n print_json(result)\n\n # Next WAV\n line = sys.stdin.buffer.readline().strip()\n if not line:\n break\n\n num_bytes = int(line)\n else:\n # Load and convert entire input\n wav_data = await core.maybe_convert_wav(sys.stdin.buffer.read())\n\n # Transcribe\n transcription = (\n transcriber.transcribe_wav(wav_data) or Transcription.empty()\n )\n result = dataclasses.asdict(transcription)\n\n print_json(result)\n finally:\n transcriber.stop()","def webm_to_wav(webm_file: str):\n wav_file = webm_file.replace(\".webm\", \".wav\")\n wav = AudioSegment.from_file(webm_file)\n wav.export(wav_file, format=\"wav\")\n return wav_file","def morse_to_audio(words, playsound=None, name_file=\"output\\\\code_to_audio_output.wav\"):\n dot = wave.open(\"kropka.wav\", 'rb')\n dash = wave.open(\"kreska.wav\", 'rb')\n\n rate_dot = dot.getframerate()\n\n rate_dash = dash.getframerate()\n\n data_dot = dot.readframes(-1)\n data_dash = dash.readframes(-1)\n data_dot = np.fromstring(data_dot, 'Int16')\n data_dash = np.fromstring(data_dash, 'Int16')\n\n l2=len(data_dot)\n l1=len(data_dash)\n\n output=[]\n\n for element in words:\n # print(element)\n for i in range(0, len(element)):\n # print(element[i])\n if element[i] == '1':\n # playsound(\"kropka.wav\")\n output.extend(data_dot)\n\n if element[i] == '0':\n # playsound(\"kreska.wav\")\n output.extend(data_dash)\n if element[i] == ' ':\n output.extend(np.zeros(int(len(data_dash)))*3)\n if i != len(element) - 1:\n # time.sleep(dl_kropka)\n output.extend(np.zeros(int(len(data_dot))))\n else:\n continue\n # time.sleep(dl_kreska)\n output.extend(np.zeros(int(len(data_dash))))\n\n # print(output)\n\n wynik=np.asarray(output)\n\n wynik=np.array(wynik).astype('int16')\n\n wav.write(name_file, rate_dash, wynik)\n\n #plik sie nie odtwarza w windowsie ale w audacity jest już wyraźnym szumem XD\n\n dot.close()\n dash.close()","def process_audio(fname, output_dir, poller):\n result = []\n try:\n if poller.params.candidate_transcripts is not None:\n out_path = \"{}/{}{}\".format(output_dir, os.path.splitext(os.path.basename(fname))[0], \".json\")\n else:\n out_path = \"{}/{}{}\".format(output_dir, os.path.splitext(os.path.basename(fname))[0], \".txt\")\n audio, audio_length = load_audio(fname, poller.params.model.sampleRate())\n pred = transcribe_audio(poller.params.model, audio, candidate_transcripts=poller.params.candidate_transcripts)\n with open(out_path, \"w\") as fp:\n fp.write(pred)\n result.append(out_path)\n except KeyboardInterrupt:\n poller.keyboard_interrupt()\n except:\n poller.error(\"Failed to process audio file: %s\\n%s\" % (fname, traceback.format_exc()))\n return result","def setup_audio(self):\n\t\t\n\t\tpath_to_file = '/var/lib/snips/skills/snips_app_pilldispenser/settings/setup_audio.sh'\n\t\tsubprocess.call([path_to_file])","def wav2mfcc(file_path, max_len=44, n_mfcc=20):","def convert_files(enumerated_src_file):\n i, src_file = enumerated_src_file\n src_file = src_file.strip()\n file_extension, acodec, quality = audio_codec()\n\n dst_file = '.'.join(src_file.split('.')[:-1]) + file_extension\n sys.stdout.write(str(i + 1) + ': ' + src_file + ' -> ' + dst_file + '\\n')\n subprocess.call(['ffmpeg', '-i', src_file, '-vn', '-acodec',\n acodec, '-aq', quality, dst_file, '-loglevel', 'quiet'])\n return src_file","def normalize_audio(audio_path: str, output_path: str, name: str):\n sound = AudioSegment.from_file(audio_path + os.sep + name + '.wav',\n \"wav\")\n change_in_d_bfs = (-20.0) - sound.dBFS\n sound = sound.apply_gain(change_in_d_bfs)\n sound.export(output_path + os.sep + name + '.wav', format=\"wav\")","def sp_audio_pipeline(wav):\n sig = sb.dataio.dataio.read_audio(wav)\n sig = sig.unsqueeze(0)\n sig = hparams[\"speed_perturb\"](sig)\n sig = sig.squeeze(0)\n return sig","def remux_audio(filename, title):\n dbg(\"starting remux\")\n temp_file = filename + \".\" + str(random.randint(10000, 99999))\n os.rename(filename, temp_file)\n meta = extract_metadata(title)\n metadata = [\"title=%s\" % meta[\"title\"]]\n\n if meta[\"artist\"]:\n metadata = [\"title=%s\" % meta[\"title\"], \"-metadata\",\n \"artist=%s\" % meta[\"artist\"]]\n\n cmd = [g.muxapp, \"-y\", \"-i\", temp_file, \"-acodec\", \"copy\", \"-metadata\"]\n cmd += metadata + [\"-vn\", filename]\n dbg(cmd)\n\n try:\n with open(os.devnull, \"w\") as devnull:\n subprocess.call(cmd, stdout=devnull, stderr=subprocess.STDOUT)\n\n except OSError:\n dbg(\"Failed to remux audio using %s\", g.muxapp)\n os.rename(temp_file, filename)\n\n else:\n os.unlink(temp_file)\n dbg(\"remuxed audio file using %s\" % g.muxapp)","def _process_utterance(lf0_dir, mgc_dir, bap_dir, cmp_dir, linear_dir, basename, wav_path, text, hparams):\n\n\tif hparams.trim_silence:\n\t\ttar_wavfile = wav_path[:-4] + \"_trim.wav\"\n\t\tprint(\"raw wav path:%s\" % wav_path)\n\t\twav_raw, fs = sf.read(wav_path)\n\t\twav_trim = audio.trim_silence(wav_raw, hparams)\n\t\tsf.write(tar_wavfile, wav_trim, fs)\n\n\t\twav_path = tar_wavfile\n\n\tnFFTHalf, alpha, bap_dim = audio.get_config(hparams.sample_rate)\n\n\tmcsize = hparams.num_mgc - 1\n\n\tfilename = basename #os.path.basename(wav_path).split(\".\")[0]\n\n\tprint('extract feats for %s' % wav_path)\n\n\t# extract f0,sp,ap\n\tos.system(\"analysis %s %s/%s.f0 %s/%s.sp %s/%s.bapd\" %\n\t\t\t\t (wav_path, lf0_dir, filename,\n\t\t\t\t mgc_dir, filename, bap_dir, filename)) # get float64???\n\n # interpolate f0\n\tf0 = np.fromfile(\"%s/%s.f0\" % (lf0_dir, filename),dtype=np.float64)\n\tcontinuous_f0 = interp1d(f0, kind=\"slinear\")\n\tcontinuous_f0.tofile(\"%s/%s.f0c\" % (lf0_dir, filename))\n\n\t# convert f0 to lf0\n\tos.system(\"x2x +da %s/%s.f0c > %s/%s.f0a\" % (lf0_dir, filename, lf0_dir, filename))\n\tos.system(\"x2x +af %s/%s.f0a | sopr -magic 0.0 -LN -MAGIC -1.0E+10 > %s/%s.lf0\" % (\n\t\tlf0_dir, filename, lf0_dir, filename))\n\n\t# convert sp to mgc\n\tos.system(\"x2x +df %s/%s.sp | sopr -R -m 32768.0 | \"\n\t\t\t \"mcep -a %f -m %d -l %d -e 1.0E-8 -j 0 -f 0.0 -q 3 \"\n\t\t\t \"> %s/%s.mgc\" % (mgc_dir, filename, alpha, mcsize, nFFTHalf, mgc_dir, filename))\n\n\t# convert ap to bap\n\tos.system(\"x2x +df %s/%s.bapd > %s/%s.bap\" %\n\t\t\t (bap_dir, filename, bap_dir, filename))\n\n\t# merge mgc,lf0 and bap to cmp\n\tos.system(\"merge +f -s 0 -l 1 -L %d %s/%s.mgc < %s/%s.lf0 > %s/%s.ml\" %\n\t\t\t((mcsize+1), mgc_dir, filename, lf0_dir, filename, cmp_dir, filename))\n\tos.system(\"merge +f -s 0 -l %d -L %d %s/%s.ml < %s/%s.bap > %s/%s.cmp\" %\n\t\t\t(bap_dim, (mcsize+2), cmp_dir, filename, bap_dir, filename, cmp_dir, filename))\n\n\t#if mel_frames > hparams.max_mel_frames and hparams.clip_mels_length:\n\t#\treturn None\n\n\t#Compute the linear scale spectrogram from the wav\n\twav = audio.load_wav(wav_path, hparams.sample_rate)\n\tlinear_spectrogram = audio.linearspectrogram(wav, hparams).astype(np.float32)\n\tlinear_frames = linear_spectrogram.shape[1]\n\n\t#sanity check\n\t#assert linear_frames == mel_frames\n\n\tlf0 = np.fromfile(\"%s/%s.lf0\" % (lf0_dir, filename), dtype=np.float32)\n\tmgc = np.fromfile(\"%s/%s.mgc\" % (mgc_dir, filename), dtype=np.float32)\n\tbap = np.fromfile(\"%s/%s.bap\" % (bap_dir, filename), dtype=np.float32)\n\tcmp = np.fromfile(\"%s/%s.cmp\" % (cmp_dir, filename), dtype=np.float32)\n\n\tcmp_dim = mcsize + 1 + 1 + bap_dim\n\tcmp_frames = cmp.shape[0] / cmp_dim\n\t#print(f0[:100])\n\t#print(continuous_f0[:100])\n\tprint(lf0.shape)\n\tprint(continuous_f0.shape)\n\tprint(mgc.shape)\n\tprint(bap.shape)\n\tprint(cmp_frames)\n\tprint(continuous_f0.dtype)\n\tprint(mgc.dtype)\n\tprint(bap.dtype)\n\tassert (mgc.shape[0]/(mcsize+1)) == (continuous_f0.shape[0]/1) == (bap.shape[0]/bap_dim) == cmp_frames\n\tassert cmp_dim == hparams.num_mels\n\t#assert len(out) >= cmp_frames * audio.get_hop_size(hparams)\n\n\t#time resolution adjustement\n\t#ensure length of raw audio is multiple of hop size so that we can use\n\t#transposed convolution to upsample\n\t#out = out[:mel_frames * audio.get_hop_size(hparams)]\n\t#assert len(out) % audio.get_hop_size(hparams) == 0\n\t#time_steps = len(out)\n\n\t# Write the spectrogram and audio to disk\n\t#audio_filename = 'audio-{}.npy'.format(index)\n\tcmp_mat = cmp.reshape(-1, cmp_dim)\n\tcmp_filename = 'cmp-{}.npy'.format(basename)\n\tlinear_filename = 'linear-{}.npy'.format(basename)\n\t#np.save(os.path.join(wav_dir, audio_filename), out.astype(out_dtype), allow_pickle=False)\n\tnp.save(os.path.join(cmp_dir, cmp_filename), cmp_mat, allow_pickle=False)\n\tnp.save(os.path.join(linear_dir, linear_filename), linear_spectrogram.T, allow_pickle=False)\n\t# Return a tuple describing this training example\n\treturn (cmp_filename, linear_filename, cmp_frames, text)","def main():\n\n #If the input is not appropiate abort operations\n\n if not check_input():\n print(\"Inappropiate Input.\")\n return\n\n convert_to_wav(sys.argv[1])","def make_audio(audio_path):\n content, sample_rate = librosa.load(audio_path, sr=16000)\n del sample_rate\n if content.dtype in (np.float32, np.float64):\n content = (content * np.iinfo(np.int16).max).astype(np.int16)\n return speech.RecognitionAudio(content=content.tobytes())","def get_audio(path):\n return send_from_directory('audio', path)","def pron(word):\n\n return send_from_directory('prons', word + \".mp3\", mimetype=\"audio/mpeg\")","def load_jam_audio(\n jam_in, audio_file, validate=True, strict=True, fmt=\"auto\", **kwargs\n):\n\n if isinstance(jam_in, jams.JAMS):\n jam = jam_in\n elif jam_in is None:\n jam = jams.JAMS()\n else:\n jam = jams.load(jam_in, validate=validate, strict=strict, fmt=fmt)\n\n y, sr = librosa.load(audio_file, **kwargs)\n\n if jam.file_metadata.duration is None:\n jam.file_metadata.duration = librosa.get_duration(y=y, sr=sr)\n\n return jam_pack(jam, _audio=dict(y=y, sr=sr))","def main():\n\n import os\n import numpy as np\n\n # Re-set FFMPEG\n # ffmpeg = FFMPEG_info()\n # ffmpeg.set()\n\n # Import a file, and play the sound\n # data_dir = r'/home/thomas/Coding/scikit-sound/sksound/tests'\n data_dir = 'tests'\n in_file = 'a1.wav'\n\n full_file = os.path.join(data_dir, in_file)\n try:\n # mySound = Sound(full_file)\n # mySound.play()\n # time.sleep(mySound.duration)\n mySound2 = Sound()\n mySound2.play()\n except NoFFMPEG_Error:\n pass\n\n # Test with self-generated data\n rate = 22050\n dt = 1./rate\n t = np.arange(0,0.5,dt)\n freq = 880\n x = np.sin(2*np.pi*freq*t)\n sounddata = np.int16(x*2**13)\n\n in_sound = Sound(inData=sounddata, inRate=rate)\n in_sound.summary()\n in_sound.play()\n time.sleep(in_sound.duration)\n\n print('hi')\n\n # Test if type conversion works\n in_sound2 = Sound(inData=x, inRate=rate)\n in_sound2.play()\n\n # Test with GUI\n in_sound = Sound()\n in_sound.play()\n print(in_sound.summary())\n out = in_sound.get_info()\n print(out)\n in_sound.write_wav()","def main():\n input_video = sys.argv[1]\n input_audio = sys.argv[2]\n output_video = sys.argv[3]\n set_audio(input_video, input_audio, output_video)","def main():\n convert(\"env_100000.mp4\", TargetFormat.GIF)","def stt_google_wav(audio_fname):\n\n print \"Sending \", audio_fname\n #Convert to flac first\n filename = audio_fname\n del_flac = False\n if 'flac' not in filename:\n del_flac = True\n print \"Converting to flac\"\n print FLAC_CONV + filename\n os.system(FLAC_CONV + ' ' + filename)\n filename = filename.split('.')[0] + '.flac'\n\n f = open(filename, 'rb')\n flac_cont = f.read()\n f.close()\n \n req = urllib2.Request(GOOGLE_SPEECH_URL, data=flac_cont, headers={'Content-type': 'audio/x-flac; rate=44100;'})\n\n try:\n\tret = urllib2.urlopen(req)\n except urllib2.URLError:\n print \"Error Transcribing Voicemail\"\n sys.exit(1)\n\n responses=[]\n responses = ret.read()\n #print responses\n text = json.loads(json.dumps(responses))\n\n if del_flac:\n os.remove(filename) # Remove temp file\n\n return text","def mels_to_audio(\n self, mels: np.ndarray, settings: typing.Optional[SettingsType] = None,\n ) -> np.ndarray:\n pass","def concatenate_wav(path_master_wav_repo, path_target_wavfile, sox_script_file):\n\n\n # SANITY-CHECK:\n # Renaming the directories appropriately if not renamed already\n replace_keys(path_master_wav_repo, ' ', '_')\n replace_keys(path_master_wav_repo, '\\'', '') # replacing special characters\n replace_keys(path_master_wav_repo, '(', '') # replacing special characters\n replace_keys(path_master_wav_repo, ')', '') # replacing special characters\n replace_keys(path_master_wav_repo, '&', '_') # replacing special characters\n\n sox_script = open(sox_script_file, 'w') # ToDo: do sanity-check if the file exists or not\n\n\n for subdir, dirs, files in os.walk(path_master_wav_repo):\n for file in files:\n if file.endswith('.wav'):\n file_path = os.path.join(subdir, file)\n sox_script.write(file_path + ' \\\\' + '\\n')\n\n sox_script.close()\n subprocess.call(['sort', sox_script_file, '-o', sox_script_file])\n\n sox_script = open(sox_script_file, 'r')\n temp = sox_script.read()\n sox_script.close()\n sox_script = open(sox_script_file, 'w')\n sox_script.write('sox \\\\'+'\\n')\n sox_script.write(temp)\n sox_script.write(path_target_wavfile)\n sox_script.close()\n\n\n subprocess.call(['bash', sox_script_file])\n\n return None","def avi2mpg(filename):\n assert filename.endswith('.avi')\n ofile = '%s.mpg' % os.path.splitext(filename)[0]\n run_shell_cmd('ffmpeg -y -i %s -qscale:v 1 %s' % (filename, ofile), ignore=True)\n return ofile","def mp4ogg(fname):\n\n logger.info(\"(mp4ogg) encode [%s] with [%s]\" % (fname,\n settings.FFMPEG2THEORA))\n oggname = \"%s.oga\" % fname[:-4]\n\n rescom = subprocess.call([settings.FFMPEG2THEORA, fname])\n if rescom == 0:\n logger.debug(\"(mp4ogg) success on [%s]\" % fname)\n result = oggname\n else:\n logger.warning(\"(mp4ogg) subprocess failed on [%s]\" % fname)\n result = None\n\n if result:\n os.unlink(fname)\n\n return result","def transcribe_audio_file(filename):\n url = 'https://api.nexiwave.com/SpeechIndexing/file/storage/' + USERNAME +'/recording/?authData.passwd=' + PASSWORD + '&auto-redirect=true&response=application/json'\n\n # To receive transcript in plain text, instead of html format, comment this line out (for SMS, for example)\n #url = url + '&transcriptFormat=html'\n\n\n # Ready to send:\n sys.stderr.write(\"Send audio for transcript with \" + url + \"\\n\")\n r = requests.post(url, files={'mediaFileData': open(filename,'rb')})\n data = r.json()\n transcript = data['text']\n foo = data['text']\n f = open('newf.txt', 'w')\n f.write(foo)\n f.close() \n # Perform your magic here:\n print \"Transcript for \"+filename+\"=\" + transcript","def output_sound():\n try:\n subprocess.call(['ffplay', '-nodisp', '-autoexit', SOUND_FILE])\n except:\n pass","def execute(self, **kwargs):\n if \"text\" not in kwargs:\n return ''\n phrase = str(kwargs[\"text\"])\n \n names = {\n \"callie\": \"6.5\",\n \"lawrence\": \"8.5\"\n }\n name = \"callie\"\n\n #TODO find a better way of implementing TTS\n ttsfd, ttsfile = tempfile.mkstemp(\".wav\")\n outfile, outname = tempfile.mkstemp(\".wav\")\n try:\n \n tts = sp.Popen(['/opt/swift/bin/swift', '-o', ttsfile, '-n', name, phrase], stdout=sp.PIPE, stderr=sp.PIPE)\n# cmd = ('/opt/swift/bin/swift \"' + phrase + '\" -o ' + ttsname + ' && sox -V1 ' +\n# tmp + ' -t wav ' + tmp2 + ' trim 8 ;')\n# p = sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.PIPE, shell=True)\n# out, err = p.communicate()\n# if len(err) > 0:\n# return err\n\n out, err = tts.communicate()\n if not err:\n sox = sp.Popen(['sox', '-V1', ttsfile, '-t', 'wav', outname, 'trim', names[name]], stdout=sp.PIPE, stderr=sp.PIPE)\n out, err = sox.communicate()\n\n player = gst.element_factory_make(\"playbin2\", \"player\")\n bus = player.get_bus()\n bus.add_signal_watch()\n\n mainloop = gobject.MainLoop()\n\n def quit(bus, message):\n mainloop.quit()\n\n bus.connect(\"message::eos\", quit)\n bus.connect(\"message::error\", quit)\n player.set_property(\"uri\", 'file://' + outname)\n player.set_state(gst.STATE_PLAYING)\n\n try:\n mainloop.run()\n finally:\n player.set_state(gst.STATE_NULL)\n\n finally:\n try:\n os.remove(ttsfile)\n except OSError as err:\n print e\n try:\n os.remove(outname)\n except IOError as err:\n print err","def testRoundTrip(self):\n with self.test_session():\n path = os.path.join(\n resource_loader.get_data_files_path(), 'testdata/mono_10khz.wav')\n with open(path, 'rb') as f:\n original_contents = f.read()\n\n audio_op = ffmpeg.decode_audio(\n original_contents, file_format='wav', samples_per_second=10000,\n channel_count=1)\n encode_op = ffmpeg.encode_audio(\n audio_op, file_format='wav', samples_per_second=10000)\n encoded_contents = encode_op.eval()\n self.assertEqual(original_contents, encoded_contents)","def audio_with_sox(path, sample_rate, start_time, end_time):\n try:\n with NamedTemporaryFile(suffix=\".wav\") as tar_file:\n tar_filename = tar_file.name\n sox_params = \"sox \\\"{}\\\" -r {} -c 1 -b 16 -e si {} trim {} ={} >/dev/null 2>&1\".format(path, sample_rate,\n tar_filename,\n start_time,\n end_time)\n os.system(sox_params)\n y = load_audio(tar_filename)\n except Exception as E:\n y = load_audio(path)\n return y","def downmixWAV(self, wavf: str) -> None:\n # HACK: https://github.com/jiaaro/pydub/issues/129\n # FIXME: a reliable method to get number of wav channels\n multichannel = True\n try:\n w = wave.open(wavf, 'rb')\n if w.getnchannels() < 3:\n multichannel = False\n w.close()\n except Exception:\n pass\n if multichannel:\n newwavf = wavf[:-4] + \"-stereo.wav\"\n FNULL = open(os.devnull, 'w')\n subprocess.call(['ffmpeg', '-y', '-i', wavf, '-c:a', 'pcm_s24le', '-ac', '2', newwavf], stdout=FNULL, stderr=FNULL)\n FNULL.close()\n os.remove(wavf)\n os.rename(newwavf, wavf)","def createMelody(song, outputSongFileName, timing=4):\n wavInput = (())\n wavInput1 = (())\n wavInput2 = (())\n wavInput3 = (())\n\n # Remove the beginning and end portions of the canvas that are blank\n while song[0] == ['R','R','R','R']:\n del song[0]\n while song[-1] == ['R','R','R','R']:\n del song[-1]\n\n for notesList in song:\n\n remove_dup(notesList)\n\n notesNum = []\n for i in range(len(notesList)):\n if (notesList[i].upper() == 'R'):\n notesNum.append('')\n elif (notesList[i].upper() == 'A' or notesList[i].upper() == 'B'):\n notesNum.append('3')\n else:\n notesNum.append('4')\n\n wavInput = ((notesList[0].lower() + str(notesNum[0]), timing),) + wavInput\n wavInput1 = ((notesList[1].lower() + str(notesNum[1]), timing),) + wavInput1\n wavInput2 = ((notesList[2].lower() + str(notesNum[2]), timing),) + wavInput2\n wavInput3 = ((notesList[3].lower() + str(notesNum[3]), timing),) + wavInput3\n\n\n wavInput = wavInput[::-1]\n wavInput1 = wavInput1[::-1]\n wavInput2 = wavInput2[::-1]\n wavInput3 = wavInput3[::-1]\n\n wavNames = [\".wav1.wav\",\".wav2.wav\",\".wav3.wav\",\".wav4.wav\"]\n wavInputs = [wavInput,wavInput1,wavInput2,wavInput3]\n\n validWavInputs = []\n\n for i in range(len(wavInputs)):\n if isAllRests(wavInputs[i]) == False:\n validWavInputs.append(wavInputs[i])\n\n validWavNames = wavNames[:len(validWavInputs)]\n\n call(['python','GenerateWavFiles.py',str(validWavNames) + \"@\" + str(validWavInputs)])\n\n sounds = []\n for i in range(len(validWavNames)):\n sounds.append(AudioSegment.from_wav(validWavNames[i]))\n\n combined = sounds[0]\n for i in range(1, len(sounds)):\n combined = combined.overlay(sounds[i])\n\n combined.export(outputSongFileName, format='wav')","def path_to_audio(path):\n print(path)\n audio, sr = librosa.load(path, sr=SAMPLING_RATE)\n x = audio.shape[0]\n audio = np.reshape(audio, (x, 1))\n audio = mt.array_to_tensor(audio)\n print(audio.shape)\n #audio = tf.io.read_file(path)\n #audio, _ = tf.audio.decode_wav(audio, 1, SAMPLING_RATE)\n return audio","def load_wav(wav_filepath):\n wv, _ = librosa.load(wav_filepath, sr=44100, mono=False) \n return wv","def convert_to_m4a(self,path, filename):\n codec = \"aac\"\n m4a_filename = filename + \".m4a\"\n command = [self.FFMPEG_BIN,\n \"-n\",\n \"-i\", path,\n \"-acodec\", codec,\n \"-ab\", \"128k\",\n m4a_filename\n ]\n\n return command","def test_process_mono_file(self):\n test_path = pathlib.Path(__file__).parent.absolute() / 'data/mono.wav'\n self.default_kwargs['input_file'] = test_path\n self.default_kwargs['output_file'] = pathlib.Path(self.temp_file.name)\n self.encoder = FileEncoder(**self.default_kwargs)\n self.encoder.process()","def play(self):\n\n try:\n if self.source is None:\n # If there is no source-file, write the data to a temporary WAV-file ...\n tmpFile = tempfile.NamedTemporaryFile(suffix='.wav', delete=False)\n tmpFile.close()\n self.write_wav(tmpFile.name)\n \n # ... and play that file\n if sys.platform=='win32':\n winsound.PlaySound(tmpFile.name, winsound.SND_FILENAME)\n elif sys.platform == 'darwin':\n cmd = ['afplay', tmpFile.name]\n subprocess.run(cmd)\n else:\n pygame.init()\n pygame.mixer.music.load(tmpFile.name)\n pygame.mixer.music.play()\n time.sleep(self.duration)\n \n # If you want to use FFMPEG instead, use the following commands:\n #cmd = [self.ffmpeg_info.ffplay, '-autoexit', '-nodisp', '-i', tmpFile.name]\n #subprocess.run(cmd)\n \n elif os.path.exists(self.source):\n # If you have a given input file ...\n print('Playing ' + self.source)\n \n # ... then play that one\n if sys.platform == 'win32':\n winsound.PlaySound(str(self.source), winsound.SND_FILENAME)\n elif sys.platform == 'darwin':\n cmd = ['afplay', str(self.source)]\n subprocess.run(cmd)\n else:\n pygame.init()\n pygame.mixer.music.load(self.source)\n pygame.mixer.music.play()\n time.sleep(self.duration)\n \n # If you want to use FFMPEG instead, use the following commands:\n #cmd = [self.ffmpeg_info.ffplay, '-autoexit', '-nodisp', '-i', self.source]\n #subprocess.run(cmd)\n \n except SystemError:\n print('If you don''t have FFMPEG available, you can e.g. use installed audio-files. E.g.:')\n print('import subprocess')\n print('subprocess.run([r\"C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe\", r\"C:\\Music\\14_Streets_of_Philadelphia.mp3\"])')","def decode_audio(fp, fs=None, mono=False, normalize=False, fastwav=False, measured = False):\n if measured:\n fp = fp.decode('latin').replace(\"clean\", \"measured\")\n\n if fastwav:\n # Read with scipy wavread (fast).\n _fs, _wav = wavread(fp)\n if fs is not None and fs != _fs:\n raise NotImplementedError('Fastwav cannot resample audio.')\n if _wav.dtype == np.int16:\n _wav = _wav.astype(np.float32)\n _wav /= 32768.\n elif _wav.dtype == np.float32:\n pass\n else:\n raise NotImplementedError('Fastwav cannot process atypical WAV files.')\n else:\n # TODO: librosa currently optional due to issue with cluster installation\n import librosa\n # Decode with librosa load (slow but supports file formats like mp3).\n _wav, _fs = librosa.core.load(fp, sr=fs, mono=False)\n if _wav.ndim == 2:\n _wav = np.swapaxes(_wav, 0, 1)\n\n assert _wav.dtype == np.float32\n\n # At this point, _wav is np.float32 either [nsamps,] or [nsamps, nch].\n # We want [nsamps, 1, nch] to mimic 2D shape of spectral feats.\n if _wav.ndim == 1:\n nsamps = _wav.shape[0]\n nch = 1\n else:\n nsamps, nch = _wav.shape\n _wav = np.reshape(_wav, [nsamps, 1, nch])\n \n # Average channels if we want monaural audio.\n if mono:\n _wav = np.mean(_wav, 2, keepdims=True)\n\n if normalize:\n _wav /= np.max(np.abs(_wav))\n\n return _wav","def wavread(filename):\n\n\tif (os.path.isfile(filename) == False): # raise error if wrong input file\n\t\traise ValueError(\"Input file is wrong\")\n\n\tfs, x = read(filename)\n\n\tif (len(x.shape) !=1): # raise error if more than one channel\n x = np.mean(x,axis = 1)\n\t\tprint \"Audio file is stereo, converting to mono\"\n\n\t#scale down and convert audio into floating point number in range of -1 to 1\n\tx = np.float32(x)/norm_fact[x.dtype.name]\n\treturn fs, x","def audio_codec():\n arguments = map_arguments()\n if arguments['-c'] == 'ogg':\n return '.ogg', 'libvorbis', arguments['-q']\n elif arguments['-c'] == 'mp3':\n return '.mp3', 'libmp3lame', arguments['-q']","def output_beat_to_file(file_name, e):\n print(\"Writing to file:\", file_name)\n routine = gp.compile(e,pset)\n with open(file_name+\".raw\",'w') as f:\n for t in range(200000):\n f.write(chr(int(routine(t+1))%256))\n # Now convert to wav\n subprocess.call(SOX_COMMAND + \" \" + file_name + \".raw\" + \" \" + file_name + \".wav\", shell=True)\n subprocess.call(LAME_COMMAND + \" \" + file_name + \".wav\", shell=True)","def inputwav(filename):\n data, sr = sf.read(filename)\n print('Decoding \"'+filename+'\"...')\n print('Sample rate is '+str(sr)+'...')\n try:\n ch=len(data[0,])\n except:\n ch=1\n print('File contains '+str(ch)+' audio channel(s)...')\n #Reshape the data so other functions can interpret the array if mono.\n #basically transposing the data\n if ch==1:\n data=data.reshape(-1,1)\n n=len(data)\n #This prevents log(data) producing nan when data is 0\n data[np.where(data==0)]=0.00001\n #convert to dB\n data_dB=20*np.log10(abs(data))\n return n, data,data_dB,sr, ch","def tag_file(filename, artist, title, year=None, genre=None, artwork_url=None, album=None, track_number=None, url=None):\n\n try:\n audio = EasyMP3(filename)\n audio.tags = None\n audio[\"artist\"] = artist\n audio[\"title\"] = title\n if year:\n audio[\"date\"] = str(year)\n if album:\n audio[\"album\"] = album\n if track_number:\n audio[\"tracknumber\"] = track_number\n if genre:\n audio[\"genre\"] = genre\n if url: # saves the tag as WOAR\n audio[\"website\"] = url\n audio.save()\n\n if artwork_url:\n\n artwork_url = artwork_url.replace('https', 'http')\n\n mime = 'image/jpeg'\n if '.jpg' in artwork_url:\n mime = 'image/jpeg'\n if '.png' in artwork_url:\n mime = 'image/png'\n\n if '-large' in artwork_url:\n new_artwork_url = artwork_url.replace('-large', '-t500x500')\n try:\n image_data = requests.get(new_artwork_url).content\n except Exception as e:\n # No very large image available.\n image_data = requests.get(artwork_url).content\n else:\n image_data = requests.get(artwork_url).content\n\n audio = MP3(filename, ID3=OldID3)\n audio.tags.add(\n APIC(\n encoding=3, # 3 is for utf-8\n mime=mime,\n type=3, # 3 is for the cover image\n desc='Cover',\n data=image_data\n )\n )\n audio.save()\n\n # because there is software that doesn't seem to use WOAR we save url tag again as WXXX\n if url:\n audio = MP3(filename, ID3=OldID3)\n audio.tags.add(WXXX(encoding=3, url=url))\n audio.save()\n\n return True\n\n except Exception as e:\n puts(colored.red(\"Problem tagging file: \") + colored.white(\"Is this file a WAV?\"))\n return False","def transcribe_wav( local_file_path, gcp_credentials_path=None, language_code=\"en-US\", client=None ):\n SEGMENT_SIZE = 55 * 1000 # 55 seconds\n OVERLAP_SIZE = 5 * 1000 # 5 seconds\n\n #\n # Instantiate a client\n #\n if client is None:\n client = create_api_client( gcp_credentials_path )\n\n #\n # Build the request. Because we only support WAV, don't need to define encoding\n # or sample rate.\n #\n config = {\n \"model\": \"video\", # premium model, but cost is basically nothing for single user anyway. Works MUCH better.\n \"language_code\": language_code,\n \"enable_word_time_offsets\": True,\n }\n\n #\n # GCP inline audio is restricted to just one minute. To avoid needing to setup\n # a GCP bucket, we'll split any provided audio files into 55-second chunks with\n # 5 seconds of overlap (since we'll probably split a word). IE, chunk 1 is from\n # 0:00 to 0:55, two is from 0:50 to 1:45, etc...\n #\n full_text = \"\"\n time_map = []\n full_recording = pydub.AudioSegment.from_file( local_file_path, format=\"wav\" )\n full_duration_ms = len( full_recording )\n offset = 0\n while offset < full_duration_ms:\n\n # If we're splitting into chunks, insert a hint\n if offset > 0:\n full_text += \" \" + SPLICE_STR + \" \"\n time_map.append( ( int( offset / 1000 ), SPLICE_STR ) )\n\n # Segment the clip into a RAM file\n this_clip = full_recording[ offset : min( offset + SEGMENT_SIZE, full_duration_ms ) ]\n segment_wav = io.BytesIO()\n this_clip.export( segment_wav, format=\"wav\" )\n segment_wav.seek(0)\n audio = { \"content\": segment_wav.read() }\n\n #\n # Submit the request & wait synchronously\n #\n operation = client.long_running_recognize( config, audio )\n response = operation.result()\n\n #\n # Process the response. Only take the first alternative.\n #\n for result in response.results:\n if len( result.alternatives ) < 1:\n continue\n best_guess = result.alternatives[0]\n full_text += best_guess.transcript\n time_map.extend( [ ( x.start_time.seconds + int( offset / 1000 ), x.word ) for x in best_guess.words ] )\n\n # Next offset\n offset += ( SEGMENT_SIZE - OVERLAP_SIZE )\n\n return ( full_text, time_map )","def play(path):\n sound = AudioSegment.from_mp3(path)\n playback.play(sound)","def remix(self):\n self.original = audio.LocalAudioFile(self.infile)\n #for i, segment in enumerate(self.original.analysis.segments):\n # segment.encode(\"seg_%s.mp3\" % i)\n print \"\\n\\n\\n\"\n loudnesses = [x.timbre[0] for i, x in enumerate(self.original.analysis.segments)]\n brightnesses = [x.timbre[1] for i, x in enumerate(self.original.analysis.segments)]\n flatnesses = [x.timbre[2] for i, x in enumerate(self.original.analysis.segments)]\n attacks = [x.timbre[3] for i, x in enumerate(self.original.analysis.segments)]\n timbre5 = [x.timbre[4] for i, x in enumerate(self.original.analysis.segments)]\n timbre6 = [x.timbre[5] for i, x in enumerate(self.original.analysis.segments)]\n timbre7 = [x.timbre[6] for i, x in enumerate(self.original.analysis.segments)]\n timbre8 = [x.timbre[7] for i, x in enumerate(self.original.analysis.segments)]\n timbre9 = [x.timbre[8] for i, x in enumerate(self.original.analysis.segments)]\n timbre10 = [x.timbre[9] for i, x in enumerate(self.original.analysis.segments)]\n timbre11 = [x.timbre[10] for i, x in enumerate(self.original.analysis.segments)]\n timbre12 = [x.timbre[11] for i, x in enumerate(self.original.analysis.segments)]\n\n print \"AVERAGES\"\n print \"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\" % ('loud','bright','flat','attack','t5','t6','t7','t8','t9','t10','t11','t12')\n print \"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\" % (avg(loudnesses),avg(brightnesses),avg(flatnesses),avg(attacks),avg(timbre5),avg(timbre6),avg(timbre7),avg(timbre8),avg(timbre9),avg(timbre10),avg(timbre11),avg(timbre12))\n print\n print \"STDVS\"\n print \"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\" % ('loud','bright','flat','attack','t5','t6','t7','t8','t9','t10','t11','t12')\n print \"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\" % (stddev(loudnesses),stddev(brightnesses),stddev(flatnesses),stddev(attacks),stddev(timbre5),stddev(timbre6),stddev(timbre7),stddev(timbre8),stddev(timbre9),stddev(timbre10),stddev(timbre11),stddev(timbre12))\n\n\n print \"\\tLoud\\tBright\\tFlat\\tAttack\\ttim5\\ttim6\\ttim7\\ttim8\\ttim9\\ttim10\\ttim11\\ttim12\"\n for segment in self.original.analysis.segments:\n if are_kicks(segment): print \"Kick\",\n elif are_snares(segment): print \"Snar\",\n elif are_hats(segment): print \"Hats\",\n else: print \"else\",\n print \"\\t%s\\t%s\\t%s\\t%s\\t%s\" % (segment.timbre[0], segment.timbre[1], segment.timbre[2], segment.timbre[3], segment.timbre[4])\n\n kicks = self.original.analysis.segments.that(are_kicks)\n #if kicks: kicks.encode('kicks.mp3')\n snares = self.original.analysis.segments.that(are_snares)\n #if snares: snares.encode('snares.mp3')\n hats = self.original.analysis.segments.that(are_hats)\n #if hats: hats.encode('hats.mp3')\n\n # Time to replace\n hat_sample = audio.AudioData(self.sample_path + self.template['hats'], sampleRate=44100, numChannels=2, verbose=False)\n kick_sample = audio.AudioData(self.sample_path + self.template['kick'], sampleRate=44100, numChannels=2, verbose=False)\n snare_sample = audio.AudioData(self.sample_path + self.template['snare'], sampleRate=44100, numChannels=2, verbose=False)\n \n empty = audio.AudioData(ndarray=numpy.zeros(((self.original.sampleRate * self.original.analysis.duration), 2), dtype=numpy.int16), numChannels=2, sampleRate=44100)\n\n last = 0\n for segment in kicks:\n if last + len(kick_sample.data) > segment.start:\n print \"Adding kick at %s\" % segment.start\n empty.data[self.original.sampleRate*segment.start:self.original.sampleRate*segment.start + len(kick_sample.data)] += kick_sample.data\n last = segment.start\n\n last = 0\n for segment in snares:\n if last + len(snare_sample.data) > segment.start:\n print \"Adding snare at %s\" % segment.start\n empty.data[self.original.sampleRate*segment.start:self.original.sampleRate*segment.start + len(snare_sample.data)] += snare_sample.data \n last = segment.start\n for segment in hats:\n if last + len(hat_sample.data) > segment.start:\n print \"Adding hat at %s\" % segment.start\n empty.data[self.original.sampleRate*segment.start:self.original.sampleRate*segment.start + len(hat_sample.data)] += hat_sample.data\n last = segment.start\n\n audio.mix(empty, self.original, 0.5).encode('mixed.mp3')","def convert2mel(audio,base_path,fs, n_fft,fmax,n_mels,hop_length_samples, window_lenght,type_training):\n\n path = os.path.join(base_path, audio)\n if type_training != \"train\":\n if os.path.isfile(os.path.join(base_path,\"processed_wavs_train\",audio)):\n data,_ = librosa.core.load(os.path.join(base_path,\"processed_wavs_train\",audio), sr=fs, res_type=\"kaiser_best\")\n else:\n data,_ = librosa.core.load(os.path.join(base_path,\"processed_wavs_test\",audio), sr=fs, res_type=\"kaiser_best\")\n else:\n data, _ = librosa.core.load(path, sr=fs, res_type=\"kaiser_best\")\n data = normalize_amplitude(data)\n\n powSpectrum = np.abs(stft(data+ 0.00001,n_fft,hop_length = hop_length_samples, win_length = window_lenght, window = windowing(window_lenght, sym=False), center=True, pad_mode='reflect'))**2\n\n mels = melspectrogram(y= None,n_fft=n_fft ,sr=fs ,S= powSpectrum, hop_length= hop_length_samples ,n_mels=n_mels,fmax=fmax , fmin = 0.0).T\n mels = librosa.core.power_to_db(mels, ref=np.min(mels))\n mels = mels / np.max(mels)\n\n return mels.T","def convert_and_move_file (filename, origpath, wavpath, mp4path, mono):\n name, ext = path.splitext(filename)\n if ext == \".mp4\":\n print(filename)\n convert_to_wav (filename, name, origpath, wavpath, mono)\n\n if not path.exists(mp4path):\n makedirs(mp4path)\n oldlocation = path.join(origpath, filename)\n newlocation = path.join(mp4path, filename)\n shutil.move(oldlocation, newlocation)","def convert_text(self):\n if msg.askyesno(message=\"Do you want to save audio file?\"):\n text = self.textbox.get(\"1.0\", tk.END)\n self.file.text = text\n files = [('Sound', '*.mp3')]\n mp3_file = asksaveasfile(title=\"Save your mp3 file\", filetypes=files, defaultextension=files)\n if mp3_file is not None:\n self.file.convert_text_to_mp3(languages[self.language.get()], mp3_file.name)\n msg.showinfo(title=\"Text to audio\", message=\"Done\")","def process_audio_multiprocess(file_paths_arr,\n filt_type, filt_cutoff_freq, filt_order,\n trim_margin_left, trim_margin_right, trim_top_db, trim_window_length, trim_hop_length, trim_ref, trim_preemphasis_strength,\n SAMPLE_RATE=48000, MIN_SAMPLE_RATE=15999, BIT_DEPTH=2,\n ignore_dirs=[\"Noise samples\",\"_Noisy_\",\"_Very Noisy_\"], skip_existing=False,\n in_ext_=None, out_ext=\".wav\", use_tqdm=True, dump_sample_rates=True\n ):\n import soundfile as sf\n import scipy\n from scipy import signal\n \n if dump_sample_rates:\n sample_rates = {} # array of dicts. e.g: [{path 0: sample_rate 0}, {path 1: sample_rate 1}, {path 2: sample_rate 2}, ...]\n \n skip = 0\n prev_sr = 0\n iterator = tqdm(file_paths_arr, smoothing=0.0) if use_tqdm else file_paths_arr\n for file_path in iterator: # recursive directory search\n in_ext = in_ext_ if (in_ext_ is not None) else os.path.splitext(os.path.split(file_path)[-1])[-1] # get ext from file_path or use override.\n out_path = file_path.replace(in_ext,out_ext)\n if skip_existing and os.path.exists(out_path):\n continue\n if any([filter_dir in file_path for filter_dir in ignore_dirs]):\n continue\n \n # VCTK cleanup\n #if file_path.endswith(f\"_mic1{in_ext}\"):\n # os.rename(file_path, file_path.replace(f\"_mic1{in_ext}\",in_ext))\n #if file_path.endswith(f\"_mic2{in_ext}\"):\n # continue\n try:\n native_sound, native_SR = sf.read(file_path, always_2d=True)\n except RuntimeError as ex:\n print(f'\"{os.path.split(file_path)[-1]}\" failed to load and has been deleted.\\nDELETED PATH: \"{file_path}\"')\n os.unlink(file_path)\n #raise RuntimeError(ex)\n native_sound = native_sound[:,0]# take first channel (either mono or left audio channel)\n native_sound = np.asfortranarray(native_sound).astype('float64') # and ensure the audio is contiguous\n \n if native_SR < MIN_SAMPLE_RATE: # skip any files with native_SR below the minimum\n continue\n if native_SR != SAMPLE_RATE: # ensure all audio is same Sample Rate\n try:\n sound = librosa.core.resample(native_sound, native_SR, SAMPLE_RATE)\n except ValueError as ex:\n print(ex, file_path, native_SR, len(native_sound), sep=\"\\n\")\n raise ValueError(ex)\n else:\n sound = native_sound\n \n if dump_sample_rates:\n sample_rates[os.path.abspath(out_path)] = native_SR\n \n # 24 bit -> 16 bit, 32 bit -> 16 bit\n if max(np.amax(native_sound), -np.amin(native_sound)) > (2**23): # if samples exceed values possible at 24 bit\n sound = (sound / 2**(31-15))#.astype('int16') # change bit depth from 32 bit to 16 bit\n elif max(np.amax(native_sound), -np.amin(native_sound)) > (2**15): # if samples exceed values possible at 16 bit\n sound = (sound / 2**(23-15))#.astype('int16') # change bit depth from 24 bit to 16 bit\n \n # apply audio filters\n for type_, freq_, order_ in zip(filt_type, filt_cutoff_freq, filt_order): # eg[ ['lp'], [40], [10] ] # i.e [type, freq, strength]\n sos = signal.butter(order_, freq_, type_, fs=SAMPLE_RATE, output='sos') # calcuate filter somethings\n sound = signal.sosfilt(sos, sound) # apply filter\n \n # apply audio trimming\n for i, (margin_left_, margin_right_, top_db_, window_length_, hop_length_, ref_, preemphasis_strength_) in enumerate(zip(trim_margin_left, trim_margin_right, trim_top_db, trim_window_length, trim_hop_length, trim_ref, trim_preemphasis_strength)):\n if preemphasis_strength_:\n sound_filt = librosa.effects.preemphasis(sound, coef=preemphasis_strength_)\n _, index = librosa.effects.trim(sound_filt, top_db=top_db_, frame_length=window_length_, hop_length=hop_length_, ref=ref_) # gonna be a little messed up for different sampling rates\n else:\n _, index = librosa.effects.trim(sound, top_db=top_db_, frame_length=window_length_, hop_length=hop_length_, ref=ref_) # gonna be a little messed up for different sampling rates\n try:\n sound = sound[int(max(index[0]-margin_left_, 0)):int(index[1]+margin_right_)]\n except TypeError:\n print(f'Slice Left:\\n{max(index[0]-margin_left_, 0)}\\nSlice Right:\\n{index[1]+margin_right_}')\n assert len(sound), f\"Audio trimmed to 0 length by pass {i+1}\\nconfig = {[margin_left_, margin_right_, top_db_, window_length_, hop_length_, ref_]}\\nFile_Path = '{file_path}'\"\n \n # write updated audio to file\n if os.path.exists(out_path):\n os.unlink(out_path) # using unlink incase the out_path object is a symlink\n sf.write(out_path, sound, SAMPLE_RATE)\n \n if dump_sample_rates:\n return sample_rates","def text_to_mp3(client: texttospeech.TextToSpeechClient,\n voice: texttospeech.VoiceSelectionParams,\n audio_config: texttospeech.AudioConfig,\n text: str,\n output_file_path: Path) -> None:\n lines = text.splitlines()\n\n logger.info(f'Synthesising {len(lines)} lines ...')\n\n output_file_log = output_file_path.parent / (output_file_path.stem + '_log.json')\n\n with output_file_path.open(mode='wb') as output_file:\n for (i, text_chunk) in enumerate(lines):\n # skip empty lines\n if len(text_chunk) > 0:\n input_text = texttospeech.SynthesisInput(text=text_chunk)\n try:\n logger.info(f'Synthesising speech for chunk `{i}`, size: `{len(text_chunk)}`')\n response = client.synthesize_speech(input=input_text, voice=voice, audio_config=audio_config)\n except Exception as e:\n # If a line could not be synthesised properly, return it along with the error message\n # It is possible that textract could not extract the text properly.\n logger.error(f'Speech synthesising failed! Chunk text: `{input_text}`\\nError: {e}\\n')\n _error_log = {\n 'chunk_number': i,\n 'chunk_length': len(text_chunk),\n 'chunk_text': str(text_chunk),\n 'Error message': traceback.format_exc()\n }\n with open(f'{output_file_log}', 'w') as log_out:\n json.dump(_error_log, log_out)\n continue\n output_file.write(response.audio_content)\n logger.info(f'Audio content written to `{output_file_path}`!')\n\n logger.info(f'Output saved to `{output_file_path}`')\n logger.info(f'logs at `{output_file_log}`')","def save(filename_audio, filename_jam, jam, strict=True, fmt=\"auto\", **kwargs):\n\n y = jam.sandbox.muda._audio[\"y\"]\n sr = jam.sandbox.muda._audio[\"sr\"]\n\n # First, dump the audio file\n psf.write(filename_audio, y, sr, **kwargs)\n\n # Then dump the jam\n jam.save(filename_jam, strict=strict, fmt=fmt)","def encode_audio(in_file, out_file):\r\n # construct the encoder\r\n autoencoder = keras.models.load_model(\"audio_autoencoder.model\")\r\n in_layer = keras.layers.Input(shape=(416, 1))\r\n encode = autoencoder.layers[1](in_layer)\r\n encode = autoencoder.layers[2](encode)\r\n encode = autoencoder.layers[3](encode)\r\n encode = autoencoder.layers[4](encode)\r\n encode = autoencoder.layers[5](encode)\r\n encode = autoencoder.layers[6](encode)\r\n encode = autoencoder.layers[7](encode)\r\n encode = autoencoder.layers[8](encode)\r\n encode = autoencoder.layers[9](encode)\r\n encode = autoencoder.layers[10](encode)\r\n encode = autoencoder.layers[11](encode)\r\n encode = autoencoder.layers[12](encode)\r\n encoder = keras.models.Model(in_layer, encode)\r\n\r\n # Read the file\r\n samp_rate, data = wavfile.read(in_file)\r\n # check if the file is mono or stereo\r\n if len(data.shape) == 2:\r\n data = np.concatenate(data)\r\n chans = 2\r\n else:\r\n chans = 1\r\n\r\n # Rescale integer samples over range [-32768,32767] to floats over range [0.0,1.0]\r\n data = data.astype('float32') / float(pow(2, 15))\r\n data += 1.0\r\n data = data / 2.0\r\n\r\n # Pad the samples with zeroes, if needed, to make the last encoding frame full\r\n padded = np.pad(data, (0, 416 - (len(data) % 416)), 'constant')\r\n\r\n # Construct input layer\r\n inputs = padded.reshape(len(padded) // 416, 416, 1)\r\n\r\n # Encode the data\r\n encoded = encoder.predict(inputs)\r\n\r\n # Save the encoded data, as well as the important parameters\r\n np.savez_compressed(out_file, data=encoded, rate=samp_rate, Type=1, channels=chans)","def wav_to_raw(path, log=False):\n rate, data = wavfile.read(path)\n if log:\n m, s = divmod(float(len(data))/rate, 60)\n h, m = divmod(m, 60)\n logging.info(\"Original recording length: %d h %d m %d s\" % (h, m, s))\n try:\n if data.shape[1] == 2:\n # If stereo (2-channel), take the average of the two channels.\n data = 0.5 * (data[:, 0] + data[:, 1])\n if log:\n logging.info('Stereo audio')\n except IndexError:\n if log:\n logging.info('Mono audio')\n return rate, data"],"string":"[\n \"def mp3_to_wav(show_progress=True):\\n\\n # Define a devnull var to supress subprocess output\\n devnull = open(os.devnull, 'w')\\n\\n # Get a list of the filepath for each of the mp3 files in each subdirectory of data/fma_small\\n file_list = glob.glob('./../data/fma_small/*/*.mp3')\\n\\n # Get the number of files N and initialize a counter\\n N = len(file_list)\\n counter = 0\\n\\n # For each file/filepath, convert that file to wav format and save it to data/wavs/*/*.wav (so as a wave file)\\n for filepath in file_list:\\n\\n # Every 100 file conversions, print a progress update\\n if counter % 50 == 49 and show_progress:\\n progress = str(round(100 * counter / N, 2))\\n print('File conversion ' + progress + '% complete.')\\n\\n # Get the file name from the path and define a new path for the wav file\\n file_name = filepath[24:-4]\\n new_path = './../data/wavs/' + file_name + '.wav'\\n\\n # Call the subprocess using ffmpeg to convert the file to wav format (and supress all the output)\\n subprocess.call(['ffmpeg', '-i', filepath, new_path], stdout=devnull)\\n\\n # Increment the counter\\n counter += 1\",\n \"def convert_to_wav(mp3_filename):\\n\\n wav_filename = mp3_filename[:-4] + \\\".wav\\\"\\n complete_mp3FileName = os.path.join(MP3_FOLDER, mp3_filename)\\n complete_wavFileName = os.path.join(WAV_FOLDER, wav_filename)\\n\\n mp3_file = AudioSegment.from_mp3(complete_mp3FileName)\\n mp3_file.export(complete_wavFileName, format=\\\"wav\\\")\\n\\n print(f\\\"The mp3 file {complete_mp3FileName} was successfully converted to \\\" \\\\\\n + f\\\"the wav file {complete_wavFileName}.\\\")\",\n \"def convert_to_mp3(self,path, filename):\\n\\n codec = \\\"libmp3lame\\\"\\n mp3_filename = filename + \\\".mp3\\\"\\n\\n command = [self.FFMPEG_BIN,\\n \\\"-n\\\",\\n \\\"-i\\\", path,\\n \\\"-acodec\\\", codec,\\n \\\"-ab\\\", \\\"128k\\\",\\n mp3_filename\\n ]\\n\\n return command\",\n \"def convert_to_wav(fin, fout):\\n temp = subprocess.run([\\\"ffmpeg\\\",\\n \\\"-i\\\", \\n fin, \\n fout], \\n stdout=subprocess.PIPE, \\n stderr=subprocess.PIPE)\",\n \"def extract_audio_from(file, out_dir=''):\\n output_filename = f'{os.path.join(out_dir, os.path.basename(file)[:-4])}.wav'\\n os.system(f'ffmpeg -i {file} {output_filename}')\\n return output_filename\",\n \"def analyze_mp3(mp3filespec):\\n \\n # Make a temporary working directory for storing the wav file\\n # that soundstretch should analyze\\n wavfilespec = tempfile.NamedTemporaryFile(suffix='.wav') \\n \\n # Use lame to make a wav representation of the mp3 file to be analyzed\\n wav_command = 'sox %s %s' % (mp3filespec, wavfilespec.name)\\n subprocess.call([wav_command], shell=True, stderr=open(os.devnull, 'w'))\\n \\n # Call soundstretch to analyze the wav file\\n bpm_command = 'soundstretch %s -bpm' % wavfilespec.name\\n p = subprocess.Popen([bpm_command], shell=True,stdout=subprocess.PIPE)\\n output = p.communicate()[0]\\n \\n # Delete temporary working directory and its contents\\n #shutil.rmtree(workingdir)\\n\\n bpm_suggestion = _get_bpm_from_soundstretch(output)\\n\\n return fit_bpm_in_window(bpm_suggestion)\",\n \"def all_wav_to_mp3(self):\\n for each_file, artist in self.past_songs_db_data:\\n self.convert_wav_to_mp3(each_file)\",\n \"def convert_to_mp3(filename: str, title: str, start: int=None, end: int=None) -> list:\\n\\t# setup args for ffmpeg\\n\\tfile_a = f\\\"{path_to_wrk_dir}{filename}.mp4\\\" # input file\\n\\tfile_b = f\\\"{path_to_wrk_dir}{title}.mp3\\\" # output file\\n\\tfiles_b = [] # this list need if file more than 30 mb\\n\\targs = [\\n\\t\\t\\\"/usr/bin/ffmpeg\\\", # path to ffmpeg\\n\\t\\t\\\"-i\\\", # flag for input file\\n\\t\\tfile_a, # input file\\n\\t\\t\\\"-acodec\\\", # setup codec\\n\\t\\t\\\"libmp3lame\\\", # codec name\\n\\t\\t]\\n\\n\\t# now need setup timings for target encode\\n\\tif start is not None and start != 0:\\n\\t\\targs = args + [\\\"-ss\\\", str(start)]\\n\\tif end is not None and end != 0:\\n\\t\\targs = args + [\\\"-t\\\", str(end - start)]\\n\\n\\t# and last part for args to ffmpeg\\n\\targs = args + [\\n\\t\\t\\\"-metadata\\\", # setup metadata for file\\n\\t\\tf\\\"title={title}\\\", # title\\n\\t\\t\\\"-metadata\\\",\\n\\t\\tf\\\"artist={title}\\\", # and artist\\n\\t\\t\\\"-b:a\\\", # setup bitrate\\n\\t\\t\\\"320k\\\", # setup max bitrate\\n\\t\\tfile_b,\\n\\t\\t]\\n\\tprint(f\\\"{args}\\\")\\n\\t# start subprocess for encoding\\n\\tpopen = subprocess.Popen(args)\\n\\tpopen.wait()\\n\\n\\t# check size file. if he more than 30 mb, bot need split him to chunks.\\n\\tsize = getsize(file_b) / 1024 / 1024\\n\\tif size > 30 and ( start or end is None ):\\n\\t\\t# setup args for split to chunks\\n\\t\\targs = [\\n\\t\\t\\t\\\"ffprobe\\\",\\n\\t\\t\\t\\\"-show_entries\\\",\\n\\t\\t\\t\\\"format=duration\\\",\\n\\t\\t\\t\\\"-i\\\",\\n\\t\\t\\tfile_b,\\n\\t\\t\\t]\\n\\n\\t\\t# get duration video.\\n\\t\\tpopen = subprocess.Popen(args, stdout=subprocess.PIPE)\\n\\t\\tpopen.wait()\\n\\t\\toutput = popen.stdout.read()\\n\\t\\t# now we know how long this audio file\\n\\t\\t# split to 10 min chunks\\n\\t\\tdur = re.findall(r\\\"\\\\d{1,10}\\\", str(output))\\n\\t\\t# get chunks count for loop\\n\\t\\tcount_chunks = (int(dur[0]) // 600) + 1\\n\\t\\tfor chunk_start_time in range(0, count_chunks):\\n\\t\\t\\t# setup args for split\\n\\t\\t\\t# big parts of args the same for encode\\n\\t\\t\\targs = [\\n\\t\\t\\t\\t\\\"/usr/bin/ffmpeg\\\",\\n\\t\\t\\t\\t\\\"-i\\\",\\n\\t\\t\\t\\tfile_b,\\n\\t\\t\\t\\t\\\"-ss\\\",\\n\\t\\t\\t\\tf\\\"{chunk_start_time * 600}\\\", # when start chunk\\n\\t\\t\\t\\t\\\"-t\\\",\\n\\t\\t\\t\\t\\\"600\\\", # 10 mints duration\\n\\t\\t\\t\\t\\\"-acodec\\\",\\n\\t\\t\\t\\t\\\"copy\\\", # copy\\n\\t\\t\\t\\t\\\"-b:a\\\",\\n\\t\\t\\t\\t\\\"320k\\\",\\n\\t\\t\\t\\tf\\\"{path_to_wrk_dir}{title}_{chunk_start_time}.mp3\\\", # now we have path to video with chunk number.\\n\\t\\t\\t]\\n\\t\\t\\ttry:\\n\\t\\t\\t\\t# start process for cut chunk\\n\\t\\t\\t\\tpopen = subprocess.Popen(args, stdout=subprocess.PIPE)\\n\\t\\t\\t\\tpopen.wait()\\n\\t\\t\\t# handle except.\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tprint(f\\\"Exception - {e}\\\")\\n\\t\\t\\tfiles_b.append(f\\\"{path_to_wrk_dir}{title}_{chunk_start_time}.mp3\\\") # append name of file in list\\n\\t\\tremove(file_b)\\n\\ttry:\\n\\t\\t# remove tmp file\\n\\t\\tremove(file_a)\\n\\t# handle except\\n\\texcept FileNotFoundError:\\n\\t\\tfiles = get_file_list(path_to_wrk_dir)\\n\\t\\tfor i in files:\\n\\t\\t\\tif -1 != f\\\"{path_to_wrk_dir}{i}\\\".find(f\\\"{filename}\\\") and f\\\"{i}\\\".find(f\\\".mp3\\\") == -1:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tremove(f\\\"{path_to_wrk_dir}{i}\\\")\\n\\t\\t\\t\\texcept FileNotFoundError:\\n\\t\\t\\t\\t\\tprint(f\\\"can't remove file {path_to_wrk_dir}{i}\\\")\\n\\tif len(files_b) == 0:\\n\\t\\treturn [file_b]\\n\\telse:\\n\\t\\treturn files_b\",\n \"def extract_audio(file_name, audio_directory):\\n basename = os.path.splitext(os.path.basename(file_name))[0]\\n audio_file_name = audio_directory + '/' + basename + '.wav'\\n subprocess.call(['ffmpeg', '-y', '-i', file_name, '-ac', '1', audio_file_name])\\n return audio_file_name\",\n \"def mp3_to_wav(song_dir, snip_dir, bird_list_path='bird_list.txt'):\\n if os.path.exists(snip_dir):\\n shutil.rmtree(snip_dir)\\n os.makedirs(snip_dir)\\n with open(bird_list_path) as f:\\n lines = f.readlines()\\n bird_list = [line.rstrip('\\\\n') for line in lines]\\n # Build the bird-labeled subdirectories in 'snip_dir'.\\n _make_bird_dirs(snip_dir, birds_list)\\n # Populate the subdirectory with recordings converted from .mp3 to .wav.\\n for f in os.listdir(song_dir):\\n bird = extract_bird_name(f)\\n if bird in birds_list:\\n index = birds_list.index(bird)\\n wav_filename = os.path.splitext(f)[0].replace(' ', '_') + '.wav'\\n orig = os.path.join(mp3_dir, f)\\n new = os.path.join(snip_dir, str(index), wav_filename)\\n # MP3-to-WAV conversion requires the ffmpeg package.\\n call([\\\"ffmpeg\\\", \\\"-i\\\", orig, new])\",\n \"def process_sound_file(file_path):\\n\\n return to_mfcc(get_wav(file_path))\",\n \"def convert_mp3_to_ogg(self, filename: str):\\n mp3_path = os.path.join(self.directory, filename)\\n ogg_path = mp3_path.replace(self.extension_mp3, self.extension_ogg)\\n if os.path.isfile(ogg_path):\\n # already done\\n return\\n command = [FFMPEG_BIN, '-i', mp3_path, ogg_path]\\n pipe = sp.Popen(command, shell=False, stdout=sp.PIPE)\\n pipe.wait()\",\n \"def convert_to_wav (filename, name, origpath, wavpath, mono):\\n print(\\\"Converting {0} to .wav...\\\".format(filename))\\n if not re.match(r\\\".*_\\\\d+$\\\",name):\\n # If filenames do include video titles\\n name = name.rsplit('_',1)[0]\\n\\n channel, vid_num = name.rsplit('_', 1)\\n channel = re.sub(r'[^A-Za-z1-9]', '', channel)\\n newname = '_'.join([channel, vid_num])\\n\\n exportname = newname + \\\".wav\\\"\\n filepath = path.join(origpath, filename)\\n\\n if not path.exists(wavpath):\\n makedirs(wavpath)\\n exportPath = path.join(wavpath, exportname)\\n sound = AudioSegment.from_file(filepath,\\\"mp4\\\")\\n if mono == True:\\n sound = sound.set_channels(1)\\n sound.export(exportPath, format=\\\"wav\\\")\",\n \"def to_voice(item):\\r\\n item.seek(0)\\r\\n item = AudioSegment.from_file(item)\\r\\n m = io.BytesIO()\\r\\n m.name = \\\"voice.ogg\\\"\\r\\n item.split_to_mono()\\r\\n dur = len(item) / 1000\\r\\n item.export(m, format=\\\"ogg\\\", bitrate=\\\"64k\\\", codec=\\\"libopus\\\")\\r\\n m.seek(0)\\r\\n return m, dur\",\n \"def play_audio():\\n directory = os.fsencode(MINI_PATH)\\n print(directory)\\n adp= []\\n # lst = os.listdir(directory)\\n # lst.sort()\\n for file in os.listdir(directory):\\n filename = os.fsdecode(file)\\n #print(file)\\n\\n if filename.endswith(\\\".mp3\\\"): \\n adp.append(MINI_PATH+filename)\\n #print(adp)\\n adp.sort()\\n print(\\\"ADP: \\\", adp)\\n x = \\\"|\\\".join(adp)\\n print( f'concat:{x}')\\n subprocess.call(['ffmpeg', '-i', f'concat:{x}', '-acodec', 'copy', RESULT_PATH])\\n \\n for file in os.listdir(directory):\\n filename = os.fsdecode(file)\\n print(filename)\\n if filename.endswith(\\\".mp3\\\"):\\n os.remove(MINI_PATH+filename)\",\n \"def mp3ogg(fname, datas):\\n oggname = \\\"%s.ogg\\\" % fname[:-4]\\n logger.info(\\\"(mp3ogg) encode [%s]\\\" % fname)\\n logger.debug(\\\"(mp3ogg) oggenc binary path %s\\\" % settings.OGGENC)\\n logger.debug(\\\"(mp3ogg) mpg123 binary path %s\\\" % settings.MPG123)\\n\\n command = [settings.OGGENC,\\n \\\"--artist\\\", datas['artist'],\\n \\\"--title\\\", datas['title'],\\n \\\"--album\\\", datas['album'],\\n \\\"--genre\\\", datas['genre'],\\n \\\"--date\\\", datas['date'],\\n \\\"--tracknum\\\", datas['tracknumber'],\\n \\\"-o\\\", oggname,\\n \\\"-\\\"]\\n\\n try:\\n mpg = subprocess.Popen([settings.MPG123,\\n \\\"-w\\\",\\n \\\"-\\\",\\n fname],\\n stdout=subprocess.PIPE)\\n\\n ogg = subprocess.Popen(command,\\n stdin=mpg.stdout, # pylint: disable-msg=E1101\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n (stdout, stderr) = ogg.communicate()\\n logger.debug(stdout)\\n logger.error(stderr)\\n result = oggname\\n except:\\n logger.error(\\\"(mp3ogg) subprocess failed on [%s]\\\" % fname)\\n result = None\\n\\n if result:\\n os.unlink(fname)\\n\\n return result\",\n \"def main():\\n destination = Path(argv[1])\\n source_files = destination.glob(\\\"**/*.wma\\\")\\n for file in source_files:\\n new_name = file.name.rsplit(\\\".\\\", maxsplit=1)[0] + \\\".flac\\\"\\n dest = str(file.parent / new_name)\\n cmd = list(map(str, [\\\"avconv\\\", \\\"-i\\\", file, dest]))\\n if platform == \\\"win32\\\":\\n print(\\\"Running on windows... on Unix I'd run the following command:\\\")\\n print(cmd)\\n else:\\n that = Popen(cmd)\\n that.wait()\",\n \"def convert_to_wav(txt_file, sph_path, target_dir):\\n wav_dir = os.path.join(target_dir, 'wav/')\\n txt_dir = os.path.join(target_dir, 'txt/')\\n os.makedirs(wav_dir, exist_ok=True)\\n os.makedirs(txt_dir, exist_ok=True)\\n path_to_data = os.path.dirname(txt_file)\\n\\n def process(x):\\n file_path = x[\\\"audio_file\\\"]\\n text = x[\\\"transcription\\\"]\\n start_time = x[\\\"start_time\\\"]\\n duration = x[\\\"end_time\\\"] - start_time\\n file_name = os.path.splitext(os.path.basename(file_path))[0]\\n file_name = str(start_time) + \\\"_\\\" + str(duration) + file_name\\n text = text.strip().upper()\\n with open(os.path.join(txt_dir, file_name + '.txt'), 'w') as f:\\n f.write(text)\\n cmd = \\\"sox -v 0.6 -t wav {} -r {} -b 16 -c 1 -t wav {} trim {} {}\\\".format(\\n os.path.join(path_to_data, file_path),\\n args.sample_rate,\\n os.path.join(wav_dir, file_name + \\\".wav\\\"),\\n start_time,\\n duration)\\n subprocess.call([cmd], shell=True)\\n print('Converting wav to wav for {}.'.format(txt_file))\\n # generate processed data\\n data = read_transcription_file(txt_file, sph_path)\\n with ThreadPool(10) as pool:\\n pool.map(process, data)\",\n \"def check_wav(song, source_folder, temp_folder, encoder='mpg123'):\\n # Name of files\\n song_name, extension = os.path.splitext(song)\\n mp3_file = os.path.join(source_folder, song)\\n if '.wav' != extension:\\n wav_file = os.path.join(temp_folder, song_name + '.wav')\\n try:\\n if not os.path.isfile(wav_file):\\n mp3_to_wav(\\n mp3_file=mp3_file,\\n wav_file=wav_file,\\n encoder=encoder)\\n else:\\n pass\\n except MemoryError:\\n logger.error('MemoryError: %s MP3 couldn\\\\'t be transformed into WAV', song_name)\\n else: # Already a wav file\\n copyfile(mp3_file, os.path.join(temp_folder, song_name))\",\n \"def convert(\\n album,\\n):\\n for track in list_dir(album):\\n ext = splitext(track)[1]\\n if ext != \\\".mp3\\\":\\n new_track = track.replace(ext, \\\".mp3\\\")\\n if not exists(new_track):\\n track_non_mp3 = AudioSegment.from_file(track, format=ext[1:])\\n print(f\\\"{track} -> {new_track}\\\")\\n track_non_mp3.export(new_track, format=\\\"mp3\\\")\\n os.remove(track)\",\n \"def play_audio(filename):\\n os.system(AUDIOPLAYER + ' ' + filename)\",\n \"def mono(filename,wout=True):\\n n, data, data_dB,sr,ch=inputwav(filename)\\n if ch==2:\\n print('Converting to mono...')\\n L=data[:,0]\\n R=data[:,1]\\n n=len(data)\\n data_m=np.zeros((n,1))\\n data_m=L/2.0+R/2.0\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_mono.wav',data_m,sr,'PCM_16')\\n print('Done!')\\n return data_m\\n else:\\n print( \\\"Error: input is already mono stoooooooooopid!\\\")\",\n \"def wavplay(filename):\\n\\tif (os.path.isfile(filename) == False): # raise error if wrong input file\\n\\t\\tprint(\\\"Input file does not exist. Make sure you computed the analysis/synthesis\\\")\\n\\telse:\\n\\t\\tif sys.platform == \\\"linux\\\" or sys.platform == \\\"linux2\\\":\\n\\t\\t # linux\\n\\t\\t subprocess.call([\\\"aplay\\\", filename])\\n\\n\\t\\telif sys.platform == \\\"darwin\\\":\\n\\t\\t\\t# OS X\\n\\t\\t\\tsubprocess.call([\\\"afplay\\\", filename])\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"Platform not recognized\\\")\",\n \"def main(directory, wavelength=16000, replace=True):\\n\\n if os.path.isdir(directory):\\n # get the directory of mp3 files\\n mpthree_files = find_directory__files(directory, 'mp3')\\n\\n # check whether there are mp3 files\\n if len(mpthree_files) > 0:\\n # converts all the mp3 files to wav files\\n map(lambda x: convert_mp3_to_wav(x, replace=replace), mpthree_files.values())\\n\\n # now get the wav files after conversion(if any)\\n wav_files = find_directory__files(directory, 'wav')\\n\\n # convert\\n map(lambda x: convert_wavelength_file(x, wavelength=wavelength, replace=replace), wav_files.values())\\n elif os.path.isfile(directory):\\n\\n # check if it's a wav\\n filetype = find_filetype(directory)\\n if filetype != 'wav':\\n if filetype == 'mp3':\\n convert_mp3_to_wav(directory, replace=replace)\\n # get the new file name\\n directory = directory.replace('mp3', 'wav')\\n else:\\n raise ValueError(\\\"Not a supported filetype at this moment\\\")\\n\\n # when filetype == wav or after converting from mp3 to wav\\n convert_wavelength_file(directory, wavelength, replace=replace)\\n else:\\n raise ValueError(\\\"input is wrong\\\")\",\n \"def to_audio(self, _in, _out, bitrate, file_format):\\n\\n # Default output parameter\\n # If not current directory, append '/'\\n if os.path.isdir(_out):\\n _out = '' if _out == '.' else _out + '/'\\n _out += self.get_name_from_path(_in,\\n replace=True) + '.' + file_format\\n _out = _out.replace('//', '/')\\n self.out = _out\\n\\n # File format unchecked for single inputs\\n if not check_is_video(_in):\\n msg = \\\" is not a supported media type\\\"\\n self.abort_conversion(\\n self.get_name_from_path(_in) + msg)\\n\\n \\\"\\\"\\\"\\n else:\\n base_name = os.path.basename(_out)\\n ext = os.path.splitext(base_name)[1]\\n _out = _out.replace(ext, '.mp3')\\n \\\"\\\"\\\"\\n commands = ['ffmpeg', '-i', _in,\\n '-vn', '-ar', '44100',\\n '-ac', '2', '-ab',\\n bitrate, _out]\\n try:\\n self.run_convert_commands(commands)\\n except FileNotFoundError as er:\\n res = require_ffmepg()\\n\\n if not res:\\n self.abort_conversion(\\\"Dependecy not installed.\\\")\",\n \"def encodeMP3(self, wavf: str, dstf: str, cover: str, meta: TrackMeta) -> None:\\n FNULL = open(os.devnull, 'w')\\n subprocess.call(['lame', '-V2', wavf, dstf], stdout=FNULL, stderr=FNULL)\\n FNULL.close()\\n # tag MP3\\n mm = TrackMeta(meta)\\n mp3 = MP3(dstf, ID3=ID3)\\n mp3[\\\"TIT2\\\"] = TIT2(encoding=3, text=mm.title())\\n mp3[\\\"TPE1\\\"] = TPE1(encoding=3, text=mm.artist())\\n mp3[\\\"TALB\\\"] = TALB(encoding=3, text=mm.album())\\n mp3[\\\"TPE2\\\"] = TPE2(encoding=3, text=mm.albumartist())\\n if mm.date():\\n mp3[\\\"TDRC\\\"] = TDRC(encoding=3, text=mm.date())\\n mp3[\\\"TRCK\\\"] = TRCK(encoding=3,\\n text=mm.tracknumber() + \\\"/\\\" + mm.tracktotal())\\n mp3[\\\"TPOS\\\"] = TPOS(encoding=3,\\n text=mm.discnumber() + \\\"/\\\" + mm.disctotal())\\n\\n # composer\\n if mm.composer():\\n mp3[\\\"TCM\\\"] = TCM(encoding=3, text=mm.composer())\\n\\n # cover\\n if cover:\\n data = open(cover, 'rb').read()\\n if cover.endswith('png'):\\n mime = 'image/png'\\n else:\\n mime = 'image/jpeg'\\n mp3.tags.add(APIC(encoding=3, mime=mime, type=3, desc=u'Cover', data=data))\\n\\n # save\\n mp3.save()\",\n \"def transcodetomp4(file_in, logger):\\n\\n import subprocess\\n\\n file_out = file_in.replace('.mkv', '.mp4')\\n\\n if os.path.isfile('/usr/bin/avconv'):\\n\\n convert_command = 'su securityspy -c \\\\\\\"/usr/bin/avconv -i \\\"{}\\\" -f mp4 -vcodec copy -acodec '.format(file_in) + \\\\\\n 'libfaac -b:a 112k -ac 2 -y \\\"{}\\\"'.format(file_out) + \\\"\\\\\\\"\\\"\\n\\n try:\\n subprocess.check_call(convert_command, shell=True)\\n except subprocess.CalledProcessError:\\n logger.error(\\\"The command to transcode: {} --- failed...\\\".format(convert_command))\\n return file_in\\n\\n return file_out\\n else:\\n return file_in\\n # fin\",\n \"def audio_pipeline(wav):\\n sig = sb.dataio.dataio.read_audio(wav)\\n return sig\",\n \"def audio_pipeline(wav):\\n sig = sb.dataio.dataio.read_audio(wav)\\n return sig\",\n \"def read_audio(f, downmix):\\n if f.endswith('.mp3'):\\n f = _mp3_hook(f)\\n sr, audio = scipy.io.wavfile.read(f)\\n if not audio.dtype is np.float32:\\n audio = _normalize_pcm(audio)\\n if downmix and len(audio.shape) == 2:\\n audio = down_mix(audio)\\n return sr, audio\",\n \"def mpg_convert(input_path: str, output_path: str, check=True,\\n verbose_level=0):\\n if verbose_level > 0:\\n v = '-v'\\n else:\\n v = '-q'\\n os.system('mpg123 ' + v + ' -w ' + output_path + ' ' + input_path)\\n if check:\\n if not os.path.isfile(output_path):\\n raise RuntimeError('Not able to convert file', input_path,\\n output_path)\",\n \"def wav_wav(orig, dest, **_kwargs):\\n\\n # options = kwargs.get(\\\"tree\\\").cmd_options.get(\\\"options\\\", [])\\n\\n # first demux it to 16 bit 48khz\\n dest_list = []\\n for index, orig_elem in enumerate(tools.get_iter(orig)):\\n tmp_dest = os.path.join(\\n os.path.dirname(dest),\\n \\\"{0}_{1}\\\".format(index, os.path.basename(dest)))\\n cmd = \\\"ffmpeg -i {orig} -acodec pcm_s16le -ar 48000 {dest}\\\".format(\\n dest=tmp_dest,\\n orig=orig_elem)\\n logger.debug(cmd)\\n try:\\n subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)\\n except subprocess.CalledProcessError as error:\\n logger.error(error)\\n logger.error(tools.to_unicode(error.output))\\n continue\\n dest_list.append(tmp_dest)\\n\\n if len(dest_list) > 1:\\n cmd = \\\"sox {orig} {dest}\\\".format(\\n orig=\\\" \\\".join(orig),\\n dest=dest)\\n logger.debug(cmd)\\n try:\\n subprocess.check_call(cmd, shell=True)\\n except subprocess.CalledProcessError as error:\\n logger.error(error)\\n logger.error(tools.to_unicode(error.output))\\n else:\\n os.rename(dest_list[0], dest)\\n return dest\",\n \"def make_wav(text, speed=1.0, emotion='normal', output_file='__temp.wav', output_dir=os.getcwd()):\\n open_jtalk = [OPENJTALK_BINPATH + '/open_jtalk']\\n mech = ['-x', OPENJTALK_DICPATH]\\n htsvoice = ['-m', OPENJTALK_VOICEPATH.format(emotion=emotion)]\\n speed = ['-r', str(speed)]\\n outwav = ['-ow', os.path.join(output_dir, output_file)]\\n cmd = open_jtalk + mech + htsvoice + speed + outwav\\n c = subprocess.Popen(cmd,stdin=subprocess.PIPE)\\n c.stdin.write(text.encode('utf-8'))\\n c.stdin.close()\\n c.wait()\\n return os.path.join(output_dir, output_file)\",\n \"def convert(self):\\n #lame --mp3input --silent -h -b BITRATE SOURCE TARGET\\n self.success = False\\n command = ['lame', '-h', '--silent']\\n command.append('-b ' + str(self.bitrate))\\n command.append(self.source)\\n command.append(self.target)\\n msg('command', command)\\n error = check_call(command)\\n if error != 0:\\n raise TaskError(subprocess.CalledProcessError)\\n self.success = True\",\n \"def _to_wav(self):\\n self._status = 0\\n fname = fm.file2wav(self.get_filename()) \\n if fname != self.get_filename(): # can change the name\\n self._set_filename(fname) # in case of wave transcoding\\n self._status = 1\",\n \"def convert_wav(src_wav, dst_wav, subtype='PCM_16'):\\n assert os.path.exists(src_wav), \\\"{} not exists!\\\".format(src_wav)\\n data, sr = soundfile.read(src_wav)\\n soundfile.write(dst_wav, data, sr, subtype=subtype)\",\n \"def get_audio(name, n):\\n audio_path = os.path.join(args.input_folder, name, \\\"audio.ogg\\\")\\n if not os.path.exists(audio_path):\\n ## Some folders have multiple .ogg files, so we need to first combine them into one file. Example:\\n ## |── Universe\\n ## │ ├── aligned.swc\\n ## │ ├── audio1.ogg\\n ## │ ├── audio2.ogg\\n ## │ ├── audio3.ogg\\n ## │ ├── audio4.ogg\\n ## │ ├── audiometa.txt\\n ## │ ├── info.json\\n ## │ ├── wiki.html\\n ## │ ├── wiki.txt\\n ## │ └── wiki.xml\\n\\n multiple_ogg_files = []\\n for i in range(1, 5):\\n path = os.path.join(args.input_folder, name, \\\"audio\\\" + str(i) + \\\".ogg\\\")\\n if os.path.exists(path):\\n multiple_ogg_files.append(path)\\n else:\\n break\\n if len(multiple_ogg_files) == 0:\\n return\\n elif len(multiple_ogg_files) == 1:\\n os.system(\\\"cp \\\\\\\"\\\" + multiple_ogg_files[0] + \\\"\\\\\\\" \\\\\\\"\\\" + audio_path + \\\"\\\\\\\"\\\")\\n else:\\n tmp_file_name = \\\"ffmeg_inputs.txt\\\"\\n print(\\\"tmp_file_name=\\\", tmp_file_name)\\n with open(tmp_file_name, \\\"w\\\", encoding=\\\"utf-8\\\") as tmp_file:\\n for path in multiple_ogg_files:\\n tmp_file.write(\\\"file '\\\" + path + \\\"'\\\\n\\\")\\n cmd = \\\"ffmpeg -f concat -i \\\\\\\"\\\" + tmp_file_name + \\\"\\\\\\\" -c copy \\\\\\\"\\\" + audio_path + \\\"\\\\\\\"\\\"\\n print(cmd)\\n os.system(cmd)\\n\\n output_audio_path = args.destination_folder + \\\"/audio/\\\" + str(n) + \\\".ogg\\\"\\n os.system(\\\"cp \\\\\\\"\\\" + audio_path + \\\"\\\\\\\" \\\" + output_audio_path)\",\n \"def create_audio_file():\\n # Get the response from boto3\\n raw_audio = generate_audio()\\n # pull the Audiostream object from the response from boto3\\n raw_audio = raw_audio[\\\"AudioStream\\\"]\\n # create output location\\n # process the whole block\\n with closing(raw_audio) as audio:\\n with open(\\\"output_audio.mp3\\\", \\\"wb\\\") as file:\\n file.write(raw_audio.read())\",\n \"def play_sound():\\r\\n try:\\r\\n\\r\\n file_name = r\\\"sound.mp3\\\"\\r\\n playsound.playsound(file_name)\\r\\n except OSError:\\r\\n AudioSegment.converter=r\\\"/Users/russelllamb/Downloads/ffmpeg\\\"\\r\\n sound=AudioSegment.from_mp3(r\\\"sound.mp3\\\")\\r\\n play(sound)\",\n \"def generate_audio():\\n text, lang = introduction()\\n ses = boto3.Session(profile_name=\\\"default\\\")\\n pol = ses.client(\\\"polly\\\")\\n res = pol.synthesize_speech(Text=text, LanguageCode=lang, OutputFormat=\\\"mp3\\\", VoiceId=VOICE)\\n return res\",\n \"def convert(file):\\n extension = file[-4:]\\n if extension == '.wav':\\n return file\\n if not exists(file):\\n raise IOError('%s file not found' % file)\\n if not extension in SUPPORTED_EXTENSION:\\n raise IOError('%s file format is not supported' % file)\\n if not exists(CONVERTION_DIRECTORY):\\n makedirs(CONVERTION_DIRECTORY)\\n filename = splitext(basename(file))[0]\\n path = join(CONVERTION_DIRECTORY, filename + '.wav')\\n if (not exists(path)):\\n logging.info(\\\"Converting file %s\\\" % file)\\n CONVERTERS[extension](file).export(path, format='wav')\\n return path\",\n \"def extract(path, quality=\\\"medium\\\"):\\n\\n try:\\n file = ffmpeg.input(path)\\n output_path = path[:-3] + \\\"ogg\\\"\\n if os.path.exists(output_path):\\n print(\\n f\\\"[{colored('#','yellow')}] Audio file {colored(path2title(output_path),'green')} already exists\\\"\\n )\\n return output_path\\n print(\\n f\\\"\\\\n[{colored('+','green')}] Extracting audio for file %s\\\"\\n % (colored(path2title(path), \\\"green\\\")),\\n end=\\\"\\\",\\n )\\n from util import Animation\\n\\n anim = Animation()\\n file.audio.output(\\n output_path,\\n acodec=\\\"libvorbis\\\",\\n audio_bitrate=BITRATE * get_multiplier(quality),\\n loglevel=0,\\n ).run()\\n anim.complete()\\n print(\\n f\\\"[{colored('+','green')}] Extraction completed for file %s\\\"\\n % (colored(path2title(output_path), \\\"green\\\"))\\n )\\n\\n except Exception as ex:\\n print(\\n f\\\"[{colored('-','red')}] There was an error extracting the audio for path {colored(path2title(output_path),'green')}: \\\",\\n ex,\\n )\\n sys.exit(-1)\\n\\n return output_path\",\n \"def get_large_audio_transcription(path):\\n # open the audio file using pydub\\n r = sr.Recognizer()\\n sound = AudioSegment.from_mp3(path)\\n sound.export(\\\"tmp.wav\\\", format=\\\"wav\\\")\\n sound = AudioSegment.from_wav('tmp.wav')\\n # split audio sound where silence is 700 miliseconds or more and get chunks\\n chunks = split_on_silence(sound,\\n # experiment with this value for your target audio file\\n min_silence_len = 500,\\n # adjust this per requirement\\n silence_thresh = sound.dBFS-14,\\n # keep the silence for 1 second, adjustable as well\\n keep_silence=500,\\n )\\n folder_name = \\\"audio-chunks\\\"\\n # create a directory to store the audio chunks\\n if not os.path.isdir(folder_name):\\n os.mkdir(folder_name)\\n whole_text = \\\"\\\"\\n\\n chapter=(str(path.split('/')[-1])).split('_')[3]\\n # if chapter == '01':\\n # target=2\\n # else:\\n # target=1\\n target=2\\n # process each chunk\\n for i, audio_chunk in enumerate(chunks, start=1):\\n # export audio chunk and save it in\\n # the `folder_name` directory.\\n if i==1:\\n chunk_filename = os.path.join(folder_name, f\\\"chunk{i}.wav\\\")\\n audio_chunk.export(chunk_filename, format=\\\"wav\\\")\\n # recognize the chunk\\n with sr.AudioFile(chunk_filename) as source:\\n audio_listened = r.record(source)\\n # try converting it to text\\n try:\\n text = r.recognize_google(audio_listened,language=\\\"en-US\\\")\\n\\n except sr.UnknownValueError as e:\\n print(\\\"Error:\\\", str(e))\\n else:\\n #text = f\\\"{text.capitalize()}. \\\"\\n #print(chunk_filename, \\\":\\\", text)\\n whole_text += text\\n # return the text for all chunks detected\\n else:\\n chunk_filename = os.path.join(folder_name, f\\\"chunk{i}.wav\\\")\\n audio_chunk.export(chunk_filename, format=\\\"wav\\\")\\n # recognize the chunk\\n with sr.AudioFile(chunk_filename) as source:\\n audio_listened = r.record(source)\\n # try converting it to text\\n try:\\n text = r.recognize_google(audio_listened, language=\\\"en-US\\\")\\n\\n except sr.UnknownValueError as e:\\n print(\\\"Error:\\\", str(e))\\n else:\\n #text = f\\\"{text.capitalize()}. \\\"\\n # print(chunk_filename, \\\":\\\", text)\\n if chapter == '01':\\n whole_text += ' ' +text\\n if str(text).isalnum():\\n if str(text).split(' ')[0]==' ':\\n whole_text += text\\n else: whole_text += ' '+text\\n # return the text for all chunks detected\\n\\n if i==target:\\n break\\n if os.path.isfile('tmp.wav') :os.remove('tmp.wav')\\n subprocess.run([\\\"rm\\\", \\\"-rf\\\", folder_name])\\n return whole_text\",\n \"def save_mp3(ndarray, sr, feature_name, out_path, x, y, new_labels, mp3_filename=None):\\n import soundfile as sf\\n\\n def _save_mp3(source_path, out_path):\\n cmd = [\\n 'lame',\\n '--preset',\\n 'insane',\\n str(source_path),\\n str(out_path)\\n ]\\n errno = subprocess.call(cmd)\\n if errno:\\n print('{} encoding failed with code'.format(source_path), end=' ')\\n print(errno)\\n print('skipping...')\\n return errno\\n os.remove(source_path)\\n return 0\\n\\n # this is kind-of standard\\n if mp3_filename is None:\\n mp3_filename = FeatureExtractor.get_file_name(x, feature_name, 'mp3')\\n wav_filename = mp3_filename.replace('mp3', 'wav')\\n sf.write(str(out_path / wav_filename), ndarray, sr) # write wav file\\n errno = _save_mp3(out_path / wav_filename,\\n out_path / mp3_filename) # load wav, encode as mp3 and remove wav file\\n if errno:\\n # if any error, then keep wav\\n filename = wav_filename\\n else:\\n # non-error clause, then it was successfully exported to mp3\\n filename = mp3_filename\\n if new_labels is not None:\\n new_labels.append([filename, y])\\n print('info: {} transformed and saved!'.format(filename))\\n return filename\",\n \"def mp4_to_mp3(filepath):\\n audio_clip = AudioFileClip(filepath)\\n mp3_filename = filepath[:-3] + 'mp3'\\n audio_clip.write_audiofile(mp3_filename)\\n os.remove(filepath)\\n audio_clip.close()\",\n \"def enregistre_audio(\\n audio: AudioSegment, \\n chemin:str = 'animalese.wav',\\n format:str ='wav'\\n ) -> AudioSegment:\\n\\n which = pydub.utils.which\\n\\n if which(\\\"avconv\\\"):\\n app = \\\"avconv\\\"\\n elif which(\\\"ffmpeg\\\"):\\n app = \\\"ffmpeg\\\"\\n elif format not in {'raw', 'wav'}:\\n raise FileNotFoundError(\\\"ffmpeg/avconv introuvable.\\\") \\n\\n return audio.export(chemin, format=format)\",\n \"def create_wav_file(self, ):\\n\\n f_out = open(self.wav_file, 'w')\\n u_utt2spk = open(self.utt2spk, 'w')\\n for file in glob.glob(self.wav_folder+'/*.wav'):\\n base = os.path.basename(file).split('.')[0]\\n # write to scp file\\n f_out.write(base + '\\\\t' + file + '\\\\n')\\n u_utt2spk.write(base + '\\\\t' + 'tts' + '\\\\n')\",\n \"async def transcribe_wav(args: argparse.Namespace, core: Voice2JsonCore) -> None:\\n from rhasspyasr import Transcription\\n\\n # Make sure profile has been trained\\n assert core.check_trained(), \\\"Not trained\\\"\\n\\n # Get speech to text transcriber for profile\\n transcriber = core.get_transcriber(open_transcription=args.open, debug=args.debug)\\n\\n # Directory to report WAV file names relative to\\n relative_dir = (\\n None if args.relative_directory is None else Path(args.relative_directory)\\n )\\n\\n try:\\n if args.wav_file or args.stdin_files:\\n # Read WAV file paths\\n wav_files = args.wav_file\\n if args.stdin_files:\\n _LOGGER.debug(\\\"Reading file paths from stdin\\\")\\n wav_files = itertools.chain(wav_files, sys.stdin)\\n\\n for wav_path_str in wav_files:\\n wav_path_str = wav_path_str.strip()\\n\\n # Load and convert\\n wav_path = Path(wav_path_str)\\n _LOGGER.debug(\\\"Transcribing %s\\\", wav_path)\\n\\n wav_data = await core.maybe_convert_wav(wav_path.read_bytes())\\n\\n # Transcribe\\n transcription = (\\n transcriber.transcribe_wav(wav_data) or Transcription.empty()\\n )\\n result = dataclasses.asdict(transcription)\\n\\n if relative_dir is None:\\n # Add name of WAV file to result\\n result[\\\"wav_name\\\"] = wav_path.name\\n else:\\n # Make relative to some directory\\n result[\\\"wav_name\\\"] = str(\\n wav_path.absolute().relative_to(relative_dir.absolute())\\n )\\n\\n print_json(result)\\n else:\\n # Read WAV data from stdin\\n _LOGGER.debug(\\\"Reading WAV data from stdin\\\")\\n\\n if args.input_size:\\n # Number of bytes is on separate line\\n line = sys.stdin.buffer.readline().strip()\\n if not line:\\n return\\n\\n num_bytes = int(line)\\n while num_bytes > 0:\\n # Read in WAV\\n wav_data = sys.stdin.buffer.read(num_bytes)\\n while len(wav_data) < num_bytes:\\n wav_data = sys.stdin.buffer.read(num_bytes - len(wav_data))\\n\\n # Transcribe\\n wav_data = await core.maybe_convert_wav(wav_data)\\n transcription = (\\n transcriber.transcribe_wav(wav_data) or Transcription.empty()\\n )\\n result = dataclasses.asdict(transcription)\\n\\n print_json(result)\\n\\n # Next WAV\\n line = sys.stdin.buffer.readline().strip()\\n if not line:\\n break\\n\\n num_bytes = int(line)\\n else:\\n # Load and convert entire input\\n wav_data = await core.maybe_convert_wav(sys.stdin.buffer.read())\\n\\n # Transcribe\\n transcription = (\\n transcriber.transcribe_wav(wav_data) or Transcription.empty()\\n )\\n result = dataclasses.asdict(transcription)\\n\\n print_json(result)\\n finally:\\n transcriber.stop()\",\n \"def webm_to_wav(webm_file: str):\\n wav_file = webm_file.replace(\\\".webm\\\", \\\".wav\\\")\\n wav = AudioSegment.from_file(webm_file)\\n wav.export(wav_file, format=\\\"wav\\\")\\n return wav_file\",\n \"def morse_to_audio(words, playsound=None, name_file=\\\"output\\\\\\\\code_to_audio_output.wav\\\"):\\n dot = wave.open(\\\"kropka.wav\\\", 'rb')\\n dash = wave.open(\\\"kreska.wav\\\", 'rb')\\n\\n rate_dot = dot.getframerate()\\n\\n rate_dash = dash.getframerate()\\n\\n data_dot = dot.readframes(-1)\\n data_dash = dash.readframes(-1)\\n data_dot = np.fromstring(data_dot, 'Int16')\\n data_dash = np.fromstring(data_dash, 'Int16')\\n\\n l2=len(data_dot)\\n l1=len(data_dash)\\n\\n output=[]\\n\\n for element in words:\\n # print(element)\\n for i in range(0, len(element)):\\n # print(element[i])\\n if element[i] == '1':\\n # playsound(\\\"kropka.wav\\\")\\n output.extend(data_dot)\\n\\n if element[i] == '0':\\n # playsound(\\\"kreska.wav\\\")\\n output.extend(data_dash)\\n if element[i] == ' ':\\n output.extend(np.zeros(int(len(data_dash)))*3)\\n if i != len(element) - 1:\\n # time.sleep(dl_kropka)\\n output.extend(np.zeros(int(len(data_dot))))\\n else:\\n continue\\n # time.sleep(dl_kreska)\\n output.extend(np.zeros(int(len(data_dash))))\\n\\n # print(output)\\n\\n wynik=np.asarray(output)\\n\\n wynik=np.array(wynik).astype('int16')\\n\\n wav.write(name_file, rate_dash, wynik)\\n\\n #plik sie nie odtwarza w windowsie ale w audacity jest już wyraźnym szumem XD\\n\\n dot.close()\\n dash.close()\",\n \"def process_audio(fname, output_dir, poller):\\n result = []\\n try:\\n if poller.params.candidate_transcripts is not None:\\n out_path = \\\"{}/{}{}\\\".format(output_dir, os.path.splitext(os.path.basename(fname))[0], \\\".json\\\")\\n else:\\n out_path = \\\"{}/{}{}\\\".format(output_dir, os.path.splitext(os.path.basename(fname))[0], \\\".txt\\\")\\n audio, audio_length = load_audio(fname, poller.params.model.sampleRate())\\n pred = transcribe_audio(poller.params.model, audio, candidate_transcripts=poller.params.candidate_transcripts)\\n with open(out_path, \\\"w\\\") as fp:\\n fp.write(pred)\\n result.append(out_path)\\n except KeyboardInterrupt:\\n poller.keyboard_interrupt()\\n except:\\n poller.error(\\\"Failed to process audio file: %s\\\\n%s\\\" % (fname, traceback.format_exc()))\\n return result\",\n \"def setup_audio(self):\\n\\t\\t\\n\\t\\tpath_to_file = '/var/lib/snips/skills/snips_app_pilldispenser/settings/setup_audio.sh'\\n\\t\\tsubprocess.call([path_to_file])\",\n \"def wav2mfcc(file_path, max_len=44, n_mfcc=20):\",\n \"def convert_files(enumerated_src_file):\\n i, src_file = enumerated_src_file\\n src_file = src_file.strip()\\n file_extension, acodec, quality = audio_codec()\\n\\n dst_file = '.'.join(src_file.split('.')[:-1]) + file_extension\\n sys.stdout.write(str(i + 1) + ': ' + src_file + ' -> ' + dst_file + '\\\\n')\\n subprocess.call(['ffmpeg', '-i', src_file, '-vn', '-acodec',\\n acodec, '-aq', quality, dst_file, '-loglevel', 'quiet'])\\n return src_file\",\n \"def normalize_audio(audio_path: str, output_path: str, name: str):\\n sound = AudioSegment.from_file(audio_path + os.sep + name + '.wav',\\n \\\"wav\\\")\\n change_in_d_bfs = (-20.0) - sound.dBFS\\n sound = sound.apply_gain(change_in_d_bfs)\\n sound.export(output_path + os.sep + name + '.wav', format=\\\"wav\\\")\",\n \"def sp_audio_pipeline(wav):\\n sig = sb.dataio.dataio.read_audio(wav)\\n sig = sig.unsqueeze(0)\\n sig = hparams[\\\"speed_perturb\\\"](sig)\\n sig = sig.squeeze(0)\\n return sig\",\n \"def remux_audio(filename, title):\\n dbg(\\\"starting remux\\\")\\n temp_file = filename + \\\".\\\" + str(random.randint(10000, 99999))\\n os.rename(filename, temp_file)\\n meta = extract_metadata(title)\\n metadata = [\\\"title=%s\\\" % meta[\\\"title\\\"]]\\n\\n if meta[\\\"artist\\\"]:\\n metadata = [\\\"title=%s\\\" % meta[\\\"title\\\"], \\\"-metadata\\\",\\n \\\"artist=%s\\\" % meta[\\\"artist\\\"]]\\n\\n cmd = [g.muxapp, \\\"-y\\\", \\\"-i\\\", temp_file, \\\"-acodec\\\", \\\"copy\\\", \\\"-metadata\\\"]\\n cmd += metadata + [\\\"-vn\\\", filename]\\n dbg(cmd)\\n\\n try:\\n with open(os.devnull, \\\"w\\\") as devnull:\\n subprocess.call(cmd, stdout=devnull, stderr=subprocess.STDOUT)\\n\\n except OSError:\\n dbg(\\\"Failed to remux audio using %s\\\", g.muxapp)\\n os.rename(temp_file, filename)\\n\\n else:\\n os.unlink(temp_file)\\n dbg(\\\"remuxed audio file using %s\\\" % g.muxapp)\",\n \"def _process_utterance(lf0_dir, mgc_dir, bap_dir, cmp_dir, linear_dir, basename, wav_path, text, hparams):\\n\\n\\tif hparams.trim_silence:\\n\\t\\ttar_wavfile = wav_path[:-4] + \\\"_trim.wav\\\"\\n\\t\\tprint(\\\"raw wav path:%s\\\" % wav_path)\\n\\t\\twav_raw, fs = sf.read(wav_path)\\n\\t\\twav_trim = audio.trim_silence(wav_raw, hparams)\\n\\t\\tsf.write(tar_wavfile, wav_trim, fs)\\n\\n\\t\\twav_path = tar_wavfile\\n\\n\\tnFFTHalf, alpha, bap_dim = audio.get_config(hparams.sample_rate)\\n\\n\\tmcsize = hparams.num_mgc - 1\\n\\n\\tfilename = basename #os.path.basename(wav_path).split(\\\".\\\")[0]\\n\\n\\tprint('extract feats for %s' % wav_path)\\n\\n\\t# extract f0,sp,ap\\n\\tos.system(\\\"analysis %s %s/%s.f0 %s/%s.sp %s/%s.bapd\\\" %\\n\\t\\t\\t\\t (wav_path, lf0_dir, filename,\\n\\t\\t\\t\\t mgc_dir, filename, bap_dir, filename)) # get float64???\\n\\n # interpolate f0\\n\\tf0 = np.fromfile(\\\"%s/%s.f0\\\" % (lf0_dir, filename),dtype=np.float64)\\n\\tcontinuous_f0 = interp1d(f0, kind=\\\"slinear\\\")\\n\\tcontinuous_f0.tofile(\\\"%s/%s.f0c\\\" % (lf0_dir, filename))\\n\\n\\t# convert f0 to lf0\\n\\tos.system(\\\"x2x +da %s/%s.f0c > %s/%s.f0a\\\" % (lf0_dir, filename, lf0_dir, filename))\\n\\tos.system(\\\"x2x +af %s/%s.f0a | sopr -magic 0.0 -LN -MAGIC -1.0E+10 > %s/%s.lf0\\\" % (\\n\\t\\tlf0_dir, filename, lf0_dir, filename))\\n\\n\\t# convert sp to mgc\\n\\tos.system(\\\"x2x +df %s/%s.sp | sopr -R -m 32768.0 | \\\"\\n\\t\\t\\t \\\"mcep -a %f -m %d -l %d -e 1.0E-8 -j 0 -f 0.0 -q 3 \\\"\\n\\t\\t\\t \\\"> %s/%s.mgc\\\" % (mgc_dir, filename, alpha, mcsize, nFFTHalf, mgc_dir, filename))\\n\\n\\t# convert ap to bap\\n\\tos.system(\\\"x2x +df %s/%s.bapd > %s/%s.bap\\\" %\\n\\t\\t\\t (bap_dir, filename, bap_dir, filename))\\n\\n\\t# merge mgc,lf0 and bap to cmp\\n\\tos.system(\\\"merge +f -s 0 -l 1 -L %d %s/%s.mgc < %s/%s.lf0 > %s/%s.ml\\\" %\\n\\t\\t\\t((mcsize+1), mgc_dir, filename, lf0_dir, filename, cmp_dir, filename))\\n\\tos.system(\\\"merge +f -s 0 -l %d -L %d %s/%s.ml < %s/%s.bap > %s/%s.cmp\\\" %\\n\\t\\t\\t(bap_dim, (mcsize+2), cmp_dir, filename, bap_dir, filename, cmp_dir, filename))\\n\\n\\t#if mel_frames > hparams.max_mel_frames and hparams.clip_mels_length:\\n\\t#\\treturn None\\n\\n\\t#Compute the linear scale spectrogram from the wav\\n\\twav = audio.load_wav(wav_path, hparams.sample_rate)\\n\\tlinear_spectrogram = audio.linearspectrogram(wav, hparams).astype(np.float32)\\n\\tlinear_frames = linear_spectrogram.shape[1]\\n\\n\\t#sanity check\\n\\t#assert linear_frames == mel_frames\\n\\n\\tlf0 = np.fromfile(\\\"%s/%s.lf0\\\" % (lf0_dir, filename), dtype=np.float32)\\n\\tmgc = np.fromfile(\\\"%s/%s.mgc\\\" % (mgc_dir, filename), dtype=np.float32)\\n\\tbap = np.fromfile(\\\"%s/%s.bap\\\" % (bap_dir, filename), dtype=np.float32)\\n\\tcmp = np.fromfile(\\\"%s/%s.cmp\\\" % (cmp_dir, filename), dtype=np.float32)\\n\\n\\tcmp_dim = mcsize + 1 + 1 + bap_dim\\n\\tcmp_frames = cmp.shape[0] / cmp_dim\\n\\t#print(f0[:100])\\n\\t#print(continuous_f0[:100])\\n\\tprint(lf0.shape)\\n\\tprint(continuous_f0.shape)\\n\\tprint(mgc.shape)\\n\\tprint(bap.shape)\\n\\tprint(cmp_frames)\\n\\tprint(continuous_f0.dtype)\\n\\tprint(mgc.dtype)\\n\\tprint(bap.dtype)\\n\\tassert (mgc.shape[0]/(mcsize+1)) == (continuous_f0.shape[0]/1) == (bap.shape[0]/bap_dim) == cmp_frames\\n\\tassert cmp_dim == hparams.num_mels\\n\\t#assert len(out) >= cmp_frames * audio.get_hop_size(hparams)\\n\\n\\t#time resolution adjustement\\n\\t#ensure length of raw audio is multiple of hop size so that we can use\\n\\t#transposed convolution to upsample\\n\\t#out = out[:mel_frames * audio.get_hop_size(hparams)]\\n\\t#assert len(out) % audio.get_hop_size(hparams) == 0\\n\\t#time_steps = len(out)\\n\\n\\t# Write the spectrogram and audio to disk\\n\\t#audio_filename = 'audio-{}.npy'.format(index)\\n\\tcmp_mat = cmp.reshape(-1, cmp_dim)\\n\\tcmp_filename = 'cmp-{}.npy'.format(basename)\\n\\tlinear_filename = 'linear-{}.npy'.format(basename)\\n\\t#np.save(os.path.join(wav_dir, audio_filename), out.astype(out_dtype), allow_pickle=False)\\n\\tnp.save(os.path.join(cmp_dir, cmp_filename), cmp_mat, allow_pickle=False)\\n\\tnp.save(os.path.join(linear_dir, linear_filename), linear_spectrogram.T, allow_pickle=False)\\n\\t# Return a tuple describing this training example\\n\\treturn (cmp_filename, linear_filename, cmp_frames, text)\",\n \"def main():\\n\\n #If the input is not appropiate abort operations\\n\\n if not check_input():\\n print(\\\"Inappropiate Input.\\\")\\n return\\n\\n convert_to_wav(sys.argv[1])\",\n \"def make_audio(audio_path):\\n content, sample_rate = librosa.load(audio_path, sr=16000)\\n del sample_rate\\n if content.dtype in (np.float32, np.float64):\\n content = (content * np.iinfo(np.int16).max).astype(np.int16)\\n return speech.RecognitionAudio(content=content.tobytes())\",\n \"def get_audio(path):\\n return send_from_directory('audio', path)\",\n \"def pron(word):\\n\\n return send_from_directory('prons', word + \\\".mp3\\\", mimetype=\\\"audio/mpeg\\\")\",\n \"def load_jam_audio(\\n jam_in, audio_file, validate=True, strict=True, fmt=\\\"auto\\\", **kwargs\\n):\\n\\n if isinstance(jam_in, jams.JAMS):\\n jam = jam_in\\n elif jam_in is None:\\n jam = jams.JAMS()\\n else:\\n jam = jams.load(jam_in, validate=validate, strict=strict, fmt=fmt)\\n\\n y, sr = librosa.load(audio_file, **kwargs)\\n\\n if jam.file_metadata.duration is None:\\n jam.file_metadata.duration = librosa.get_duration(y=y, sr=sr)\\n\\n return jam_pack(jam, _audio=dict(y=y, sr=sr))\",\n \"def main():\\n\\n import os\\n import numpy as np\\n\\n # Re-set FFMPEG\\n # ffmpeg = FFMPEG_info()\\n # ffmpeg.set()\\n\\n # Import a file, and play the sound\\n # data_dir = r'/home/thomas/Coding/scikit-sound/sksound/tests'\\n data_dir = 'tests'\\n in_file = 'a1.wav'\\n\\n full_file = os.path.join(data_dir, in_file)\\n try:\\n # mySound = Sound(full_file)\\n # mySound.play()\\n # time.sleep(mySound.duration)\\n mySound2 = Sound()\\n mySound2.play()\\n except NoFFMPEG_Error:\\n pass\\n\\n # Test with self-generated data\\n rate = 22050\\n dt = 1./rate\\n t = np.arange(0,0.5,dt)\\n freq = 880\\n x = np.sin(2*np.pi*freq*t)\\n sounddata = np.int16(x*2**13)\\n\\n in_sound = Sound(inData=sounddata, inRate=rate)\\n in_sound.summary()\\n in_sound.play()\\n time.sleep(in_sound.duration)\\n\\n print('hi')\\n\\n # Test if type conversion works\\n in_sound2 = Sound(inData=x, inRate=rate)\\n in_sound2.play()\\n\\n # Test with GUI\\n in_sound = Sound()\\n in_sound.play()\\n print(in_sound.summary())\\n out = in_sound.get_info()\\n print(out)\\n in_sound.write_wav()\",\n \"def main():\\n input_video = sys.argv[1]\\n input_audio = sys.argv[2]\\n output_video = sys.argv[3]\\n set_audio(input_video, input_audio, output_video)\",\n \"def main():\\n convert(\\\"env_100000.mp4\\\", TargetFormat.GIF)\",\n \"def stt_google_wav(audio_fname):\\n\\n print \\\"Sending \\\", audio_fname\\n #Convert to flac first\\n filename = audio_fname\\n del_flac = False\\n if 'flac' not in filename:\\n del_flac = True\\n print \\\"Converting to flac\\\"\\n print FLAC_CONV + filename\\n os.system(FLAC_CONV + ' ' + filename)\\n filename = filename.split('.')[0] + '.flac'\\n\\n f = open(filename, 'rb')\\n flac_cont = f.read()\\n f.close()\\n \\n req = urllib2.Request(GOOGLE_SPEECH_URL, data=flac_cont, headers={'Content-type': 'audio/x-flac; rate=44100;'})\\n\\n try:\\n\\tret = urllib2.urlopen(req)\\n except urllib2.URLError:\\n print \\\"Error Transcribing Voicemail\\\"\\n sys.exit(1)\\n\\n responses=[]\\n responses = ret.read()\\n #print responses\\n text = json.loads(json.dumps(responses))\\n\\n if del_flac:\\n os.remove(filename) # Remove temp file\\n\\n return text\",\n \"def mels_to_audio(\\n self, mels: np.ndarray, settings: typing.Optional[SettingsType] = None,\\n ) -> np.ndarray:\\n pass\",\n \"def concatenate_wav(path_master_wav_repo, path_target_wavfile, sox_script_file):\\n\\n\\n # SANITY-CHECK:\\n # Renaming the directories appropriately if not renamed already\\n replace_keys(path_master_wav_repo, ' ', '_')\\n replace_keys(path_master_wav_repo, '\\\\'', '') # replacing special characters\\n replace_keys(path_master_wav_repo, '(', '') # replacing special characters\\n replace_keys(path_master_wav_repo, ')', '') # replacing special characters\\n replace_keys(path_master_wav_repo, '&', '_') # replacing special characters\\n\\n sox_script = open(sox_script_file, 'w') # ToDo: do sanity-check if the file exists or not\\n\\n\\n for subdir, dirs, files in os.walk(path_master_wav_repo):\\n for file in files:\\n if file.endswith('.wav'):\\n file_path = os.path.join(subdir, file)\\n sox_script.write(file_path + ' \\\\\\\\' + '\\\\n')\\n\\n sox_script.close()\\n subprocess.call(['sort', sox_script_file, '-o', sox_script_file])\\n\\n sox_script = open(sox_script_file, 'r')\\n temp = sox_script.read()\\n sox_script.close()\\n sox_script = open(sox_script_file, 'w')\\n sox_script.write('sox \\\\\\\\'+'\\\\n')\\n sox_script.write(temp)\\n sox_script.write(path_target_wavfile)\\n sox_script.close()\\n\\n\\n subprocess.call(['bash', sox_script_file])\\n\\n return None\",\n \"def avi2mpg(filename):\\n assert filename.endswith('.avi')\\n ofile = '%s.mpg' % os.path.splitext(filename)[0]\\n run_shell_cmd('ffmpeg -y -i %s -qscale:v 1 %s' % (filename, ofile), ignore=True)\\n return ofile\",\n \"def mp4ogg(fname):\\n\\n logger.info(\\\"(mp4ogg) encode [%s] with [%s]\\\" % (fname,\\n settings.FFMPEG2THEORA))\\n oggname = \\\"%s.oga\\\" % fname[:-4]\\n\\n rescom = subprocess.call([settings.FFMPEG2THEORA, fname])\\n if rescom == 0:\\n logger.debug(\\\"(mp4ogg) success on [%s]\\\" % fname)\\n result = oggname\\n else:\\n logger.warning(\\\"(mp4ogg) subprocess failed on [%s]\\\" % fname)\\n result = None\\n\\n if result:\\n os.unlink(fname)\\n\\n return result\",\n \"def transcribe_audio_file(filename):\\n url = 'https://api.nexiwave.com/SpeechIndexing/file/storage/' + USERNAME +'/recording/?authData.passwd=' + PASSWORD + '&auto-redirect=true&response=application/json'\\n\\n # To receive transcript in plain text, instead of html format, comment this line out (for SMS, for example)\\n #url = url + '&transcriptFormat=html'\\n\\n\\n # Ready to send:\\n sys.stderr.write(\\\"Send audio for transcript with \\\" + url + \\\"\\\\n\\\")\\n r = requests.post(url, files={'mediaFileData': open(filename,'rb')})\\n data = r.json()\\n transcript = data['text']\\n foo = data['text']\\n f = open('newf.txt', 'w')\\n f.write(foo)\\n f.close() \\n # Perform your magic here:\\n print \\\"Transcript for \\\"+filename+\\\"=\\\" + transcript\",\n \"def output_sound():\\n try:\\n subprocess.call(['ffplay', '-nodisp', '-autoexit', SOUND_FILE])\\n except:\\n pass\",\n \"def execute(self, **kwargs):\\n if \\\"text\\\" not in kwargs:\\n return ''\\n phrase = str(kwargs[\\\"text\\\"])\\n \\n names = {\\n \\\"callie\\\": \\\"6.5\\\",\\n \\\"lawrence\\\": \\\"8.5\\\"\\n }\\n name = \\\"callie\\\"\\n\\n #TODO find a better way of implementing TTS\\n ttsfd, ttsfile = tempfile.mkstemp(\\\".wav\\\")\\n outfile, outname = tempfile.mkstemp(\\\".wav\\\")\\n try:\\n \\n tts = sp.Popen(['/opt/swift/bin/swift', '-o', ttsfile, '-n', name, phrase], stdout=sp.PIPE, stderr=sp.PIPE)\\n# cmd = ('/opt/swift/bin/swift \\\"' + phrase + '\\\" -o ' + ttsname + ' && sox -V1 ' +\\n# tmp + ' -t wav ' + tmp2 + ' trim 8 ;')\\n# p = sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.PIPE, shell=True)\\n# out, err = p.communicate()\\n# if len(err) > 0:\\n# return err\\n\\n out, err = tts.communicate()\\n if not err:\\n sox = sp.Popen(['sox', '-V1', ttsfile, '-t', 'wav', outname, 'trim', names[name]], stdout=sp.PIPE, stderr=sp.PIPE)\\n out, err = sox.communicate()\\n\\n player = gst.element_factory_make(\\\"playbin2\\\", \\\"player\\\")\\n bus = player.get_bus()\\n bus.add_signal_watch()\\n\\n mainloop = gobject.MainLoop()\\n\\n def quit(bus, message):\\n mainloop.quit()\\n\\n bus.connect(\\\"message::eos\\\", quit)\\n bus.connect(\\\"message::error\\\", quit)\\n player.set_property(\\\"uri\\\", 'file://' + outname)\\n player.set_state(gst.STATE_PLAYING)\\n\\n try:\\n mainloop.run()\\n finally:\\n player.set_state(gst.STATE_NULL)\\n\\n finally:\\n try:\\n os.remove(ttsfile)\\n except OSError as err:\\n print e\\n try:\\n os.remove(outname)\\n except IOError as err:\\n print err\",\n \"def testRoundTrip(self):\\n with self.test_session():\\n path = os.path.join(\\n resource_loader.get_data_files_path(), 'testdata/mono_10khz.wav')\\n with open(path, 'rb') as f:\\n original_contents = f.read()\\n\\n audio_op = ffmpeg.decode_audio(\\n original_contents, file_format='wav', samples_per_second=10000,\\n channel_count=1)\\n encode_op = ffmpeg.encode_audio(\\n audio_op, file_format='wav', samples_per_second=10000)\\n encoded_contents = encode_op.eval()\\n self.assertEqual(original_contents, encoded_contents)\",\n \"def audio_with_sox(path, sample_rate, start_time, end_time):\\n try:\\n with NamedTemporaryFile(suffix=\\\".wav\\\") as tar_file:\\n tar_filename = tar_file.name\\n sox_params = \\\"sox \\\\\\\"{}\\\\\\\" -r {} -c 1 -b 16 -e si {} trim {} ={} >/dev/null 2>&1\\\".format(path, sample_rate,\\n tar_filename,\\n start_time,\\n end_time)\\n os.system(sox_params)\\n y = load_audio(tar_filename)\\n except Exception as E:\\n y = load_audio(path)\\n return y\",\n \"def downmixWAV(self, wavf: str) -> None:\\n # HACK: https://github.com/jiaaro/pydub/issues/129\\n # FIXME: a reliable method to get number of wav channels\\n multichannel = True\\n try:\\n w = wave.open(wavf, 'rb')\\n if w.getnchannels() < 3:\\n multichannel = False\\n w.close()\\n except Exception:\\n pass\\n if multichannel:\\n newwavf = wavf[:-4] + \\\"-stereo.wav\\\"\\n FNULL = open(os.devnull, 'w')\\n subprocess.call(['ffmpeg', '-y', '-i', wavf, '-c:a', 'pcm_s24le', '-ac', '2', newwavf], stdout=FNULL, stderr=FNULL)\\n FNULL.close()\\n os.remove(wavf)\\n os.rename(newwavf, wavf)\",\n \"def createMelody(song, outputSongFileName, timing=4):\\n wavInput = (())\\n wavInput1 = (())\\n wavInput2 = (())\\n wavInput3 = (())\\n\\n # Remove the beginning and end portions of the canvas that are blank\\n while song[0] == ['R','R','R','R']:\\n del song[0]\\n while song[-1] == ['R','R','R','R']:\\n del song[-1]\\n\\n for notesList in song:\\n\\n remove_dup(notesList)\\n\\n notesNum = []\\n for i in range(len(notesList)):\\n if (notesList[i].upper() == 'R'):\\n notesNum.append('')\\n elif (notesList[i].upper() == 'A' or notesList[i].upper() == 'B'):\\n notesNum.append('3')\\n else:\\n notesNum.append('4')\\n\\n wavInput = ((notesList[0].lower() + str(notesNum[0]), timing),) + wavInput\\n wavInput1 = ((notesList[1].lower() + str(notesNum[1]), timing),) + wavInput1\\n wavInput2 = ((notesList[2].lower() + str(notesNum[2]), timing),) + wavInput2\\n wavInput3 = ((notesList[3].lower() + str(notesNum[3]), timing),) + wavInput3\\n\\n\\n wavInput = wavInput[::-1]\\n wavInput1 = wavInput1[::-1]\\n wavInput2 = wavInput2[::-1]\\n wavInput3 = wavInput3[::-1]\\n\\n wavNames = [\\\".wav1.wav\\\",\\\".wav2.wav\\\",\\\".wav3.wav\\\",\\\".wav4.wav\\\"]\\n wavInputs = [wavInput,wavInput1,wavInput2,wavInput3]\\n\\n validWavInputs = []\\n\\n for i in range(len(wavInputs)):\\n if isAllRests(wavInputs[i]) == False:\\n validWavInputs.append(wavInputs[i])\\n\\n validWavNames = wavNames[:len(validWavInputs)]\\n\\n call(['python','GenerateWavFiles.py',str(validWavNames) + \\\"@\\\" + str(validWavInputs)])\\n\\n sounds = []\\n for i in range(len(validWavNames)):\\n sounds.append(AudioSegment.from_wav(validWavNames[i]))\\n\\n combined = sounds[0]\\n for i in range(1, len(sounds)):\\n combined = combined.overlay(sounds[i])\\n\\n combined.export(outputSongFileName, format='wav')\",\n \"def path_to_audio(path):\\n print(path)\\n audio, sr = librosa.load(path, sr=SAMPLING_RATE)\\n x = audio.shape[0]\\n audio = np.reshape(audio, (x, 1))\\n audio = mt.array_to_tensor(audio)\\n print(audio.shape)\\n #audio = tf.io.read_file(path)\\n #audio, _ = tf.audio.decode_wav(audio, 1, SAMPLING_RATE)\\n return audio\",\n \"def load_wav(wav_filepath):\\n wv, _ = librosa.load(wav_filepath, sr=44100, mono=False) \\n return wv\",\n \"def convert_to_m4a(self,path, filename):\\n codec = \\\"aac\\\"\\n m4a_filename = filename + \\\".m4a\\\"\\n command = [self.FFMPEG_BIN,\\n \\\"-n\\\",\\n \\\"-i\\\", path,\\n \\\"-acodec\\\", codec,\\n \\\"-ab\\\", \\\"128k\\\",\\n m4a_filename\\n ]\\n\\n return command\",\n \"def test_process_mono_file(self):\\n test_path = pathlib.Path(__file__).parent.absolute() / 'data/mono.wav'\\n self.default_kwargs['input_file'] = test_path\\n self.default_kwargs['output_file'] = pathlib.Path(self.temp_file.name)\\n self.encoder = FileEncoder(**self.default_kwargs)\\n self.encoder.process()\",\n \"def play(self):\\n\\n try:\\n if self.source is None:\\n # If there is no source-file, write the data to a temporary WAV-file ...\\n tmpFile = tempfile.NamedTemporaryFile(suffix='.wav', delete=False)\\n tmpFile.close()\\n self.write_wav(tmpFile.name)\\n \\n # ... and play that file\\n if sys.platform=='win32':\\n winsound.PlaySound(tmpFile.name, winsound.SND_FILENAME)\\n elif sys.platform == 'darwin':\\n cmd = ['afplay', tmpFile.name]\\n subprocess.run(cmd)\\n else:\\n pygame.init()\\n pygame.mixer.music.load(tmpFile.name)\\n pygame.mixer.music.play()\\n time.sleep(self.duration)\\n \\n # If you want to use FFMPEG instead, use the following commands:\\n #cmd = [self.ffmpeg_info.ffplay, '-autoexit', '-nodisp', '-i', tmpFile.name]\\n #subprocess.run(cmd)\\n \\n elif os.path.exists(self.source):\\n # If you have a given input file ...\\n print('Playing ' + self.source)\\n \\n # ... then play that one\\n if sys.platform == 'win32':\\n winsound.PlaySound(str(self.source), winsound.SND_FILENAME)\\n elif sys.platform == 'darwin':\\n cmd = ['afplay', str(self.source)]\\n subprocess.run(cmd)\\n else:\\n pygame.init()\\n pygame.mixer.music.load(self.source)\\n pygame.mixer.music.play()\\n time.sleep(self.duration)\\n \\n # If you want to use FFMPEG instead, use the following commands:\\n #cmd = [self.ffmpeg_info.ffplay, '-autoexit', '-nodisp', '-i', self.source]\\n #subprocess.run(cmd)\\n \\n except SystemError:\\n print('If you don''t have FFMPEG available, you can e.g. use installed audio-files. E.g.:')\\n print('import subprocess')\\n print('subprocess.run([r\\\"C:\\\\Program Files (x86)\\\\VideoLAN\\\\VLC\\\\vlc.exe\\\", r\\\"C:\\\\Music\\\\14_Streets_of_Philadelphia.mp3\\\"])')\",\n \"def decode_audio(fp, fs=None, mono=False, normalize=False, fastwav=False, measured = False):\\n if measured:\\n fp = fp.decode('latin').replace(\\\"clean\\\", \\\"measured\\\")\\n\\n if fastwav:\\n # Read with scipy wavread (fast).\\n _fs, _wav = wavread(fp)\\n if fs is not None and fs != _fs:\\n raise NotImplementedError('Fastwav cannot resample audio.')\\n if _wav.dtype == np.int16:\\n _wav = _wav.astype(np.float32)\\n _wav /= 32768.\\n elif _wav.dtype == np.float32:\\n pass\\n else:\\n raise NotImplementedError('Fastwav cannot process atypical WAV files.')\\n else:\\n # TODO: librosa currently optional due to issue with cluster installation\\n import librosa\\n # Decode with librosa load (slow but supports file formats like mp3).\\n _wav, _fs = librosa.core.load(fp, sr=fs, mono=False)\\n if _wav.ndim == 2:\\n _wav = np.swapaxes(_wav, 0, 1)\\n\\n assert _wav.dtype == np.float32\\n\\n # At this point, _wav is np.float32 either [nsamps,] or [nsamps, nch].\\n # We want [nsamps, 1, nch] to mimic 2D shape of spectral feats.\\n if _wav.ndim == 1:\\n nsamps = _wav.shape[0]\\n nch = 1\\n else:\\n nsamps, nch = _wav.shape\\n _wav = np.reshape(_wav, [nsamps, 1, nch])\\n \\n # Average channels if we want monaural audio.\\n if mono:\\n _wav = np.mean(_wav, 2, keepdims=True)\\n\\n if normalize:\\n _wav /= np.max(np.abs(_wav))\\n\\n return _wav\",\n \"def wavread(filename):\\n\\n\\tif (os.path.isfile(filename) == False): # raise error if wrong input file\\n\\t\\traise ValueError(\\\"Input file is wrong\\\")\\n\\n\\tfs, x = read(filename)\\n\\n\\tif (len(x.shape) !=1): # raise error if more than one channel\\n x = np.mean(x,axis = 1)\\n\\t\\tprint \\\"Audio file is stereo, converting to mono\\\"\\n\\n\\t#scale down and convert audio into floating point number in range of -1 to 1\\n\\tx = np.float32(x)/norm_fact[x.dtype.name]\\n\\treturn fs, x\",\n \"def audio_codec():\\n arguments = map_arguments()\\n if arguments['-c'] == 'ogg':\\n return '.ogg', 'libvorbis', arguments['-q']\\n elif arguments['-c'] == 'mp3':\\n return '.mp3', 'libmp3lame', arguments['-q']\",\n \"def output_beat_to_file(file_name, e):\\n print(\\\"Writing to file:\\\", file_name)\\n routine = gp.compile(e,pset)\\n with open(file_name+\\\".raw\\\",'w') as f:\\n for t in range(200000):\\n f.write(chr(int(routine(t+1))%256))\\n # Now convert to wav\\n subprocess.call(SOX_COMMAND + \\\" \\\" + file_name + \\\".raw\\\" + \\\" \\\" + file_name + \\\".wav\\\", shell=True)\\n subprocess.call(LAME_COMMAND + \\\" \\\" + file_name + \\\".wav\\\", shell=True)\",\n \"def inputwav(filename):\\n data, sr = sf.read(filename)\\n print('Decoding \\\"'+filename+'\\\"...')\\n print('Sample rate is '+str(sr)+'...')\\n try:\\n ch=len(data[0,])\\n except:\\n ch=1\\n print('File contains '+str(ch)+' audio channel(s)...')\\n #Reshape the data so other functions can interpret the array if mono.\\n #basically transposing the data\\n if ch==1:\\n data=data.reshape(-1,1)\\n n=len(data)\\n #This prevents log(data) producing nan when data is 0\\n data[np.where(data==0)]=0.00001\\n #convert to dB\\n data_dB=20*np.log10(abs(data))\\n return n, data,data_dB,sr, ch\",\n \"def tag_file(filename, artist, title, year=None, genre=None, artwork_url=None, album=None, track_number=None, url=None):\\n\\n try:\\n audio = EasyMP3(filename)\\n audio.tags = None\\n audio[\\\"artist\\\"] = artist\\n audio[\\\"title\\\"] = title\\n if year:\\n audio[\\\"date\\\"] = str(year)\\n if album:\\n audio[\\\"album\\\"] = album\\n if track_number:\\n audio[\\\"tracknumber\\\"] = track_number\\n if genre:\\n audio[\\\"genre\\\"] = genre\\n if url: # saves the tag as WOAR\\n audio[\\\"website\\\"] = url\\n audio.save()\\n\\n if artwork_url:\\n\\n artwork_url = artwork_url.replace('https', 'http')\\n\\n mime = 'image/jpeg'\\n if '.jpg' in artwork_url:\\n mime = 'image/jpeg'\\n if '.png' in artwork_url:\\n mime = 'image/png'\\n\\n if '-large' in artwork_url:\\n new_artwork_url = artwork_url.replace('-large', '-t500x500')\\n try:\\n image_data = requests.get(new_artwork_url).content\\n except Exception as e:\\n # No very large image available.\\n image_data = requests.get(artwork_url).content\\n else:\\n image_data = requests.get(artwork_url).content\\n\\n audio = MP3(filename, ID3=OldID3)\\n audio.tags.add(\\n APIC(\\n encoding=3, # 3 is for utf-8\\n mime=mime,\\n type=3, # 3 is for the cover image\\n desc='Cover',\\n data=image_data\\n )\\n )\\n audio.save()\\n\\n # because there is software that doesn't seem to use WOAR we save url tag again as WXXX\\n if url:\\n audio = MP3(filename, ID3=OldID3)\\n audio.tags.add(WXXX(encoding=3, url=url))\\n audio.save()\\n\\n return True\\n\\n except Exception as e:\\n puts(colored.red(\\\"Problem tagging file: \\\") + colored.white(\\\"Is this file a WAV?\\\"))\\n return False\",\n \"def transcribe_wav( local_file_path, gcp_credentials_path=None, language_code=\\\"en-US\\\", client=None ):\\n SEGMENT_SIZE = 55 * 1000 # 55 seconds\\n OVERLAP_SIZE = 5 * 1000 # 5 seconds\\n\\n #\\n # Instantiate a client\\n #\\n if client is None:\\n client = create_api_client( gcp_credentials_path )\\n\\n #\\n # Build the request. Because we only support WAV, don't need to define encoding\\n # or sample rate.\\n #\\n config = {\\n \\\"model\\\": \\\"video\\\", # premium model, but cost is basically nothing for single user anyway. Works MUCH better.\\n \\\"language_code\\\": language_code,\\n \\\"enable_word_time_offsets\\\": True,\\n }\\n\\n #\\n # GCP inline audio is restricted to just one minute. To avoid needing to setup\\n # a GCP bucket, we'll split any provided audio files into 55-second chunks with\\n # 5 seconds of overlap (since we'll probably split a word). IE, chunk 1 is from\\n # 0:00 to 0:55, two is from 0:50 to 1:45, etc...\\n #\\n full_text = \\\"\\\"\\n time_map = []\\n full_recording = pydub.AudioSegment.from_file( local_file_path, format=\\\"wav\\\" )\\n full_duration_ms = len( full_recording )\\n offset = 0\\n while offset < full_duration_ms:\\n\\n # If we're splitting into chunks, insert a hint\\n if offset > 0:\\n full_text += \\\" \\\" + SPLICE_STR + \\\" \\\"\\n time_map.append( ( int( offset / 1000 ), SPLICE_STR ) )\\n\\n # Segment the clip into a RAM file\\n this_clip = full_recording[ offset : min( offset + SEGMENT_SIZE, full_duration_ms ) ]\\n segment_wav = io.BytesIO()\\n this_clip.export( segment_wav, format=\\\"wav\\\" )\\n segment_wav.seek(0)\\n audio = { \\\"content\\\": segment_wav.read() }\\n\\n #\\n # Submit the request & wait synchronously\\n #\\n operation = client.long_running_recognize( config, audio )\\n response = operation.result()\\n\\n #\\n # Process the response. Only take the first alternative.\\n #\\n for result in response.results:\\n if len( result.alternatives ) < 1:\\n continue\\n best_guess = result.alternatives[0]\\n full_text += best_guess.transcript\\n time_map.extend( [ ( x.start_time.seconds + int( offset / 1000 ), x.word ) for x in best_guess.words ] )\\n\\n # Next offset\\n offset += ( SEGMENT_SIZE - OVERLAP_SIZE )\\n\\n return ( full_text, time_map )\",\n \"def play(path):\\n sound = AudioSegment.from_mp3(path)\\n playback.play(sound)\",\n \"def remix(self):\\n self.original = audio.LocalAudioFile(self.infile)\\n #for i, segment in enumerate(self.original.analysis.segments):\\n # segment.encode(\\\"seg_%s.mp3\\\" % i)\\n print \\\"\\\\n\\\\n\\\\n\\\"\\n loudnesses = [x.timbre[0] for i, x in enumerate(self.original.analysis.segments)]\\n brightnesses = [x.timbre[1] for i, x in enumerate(self.original.analysis.segments)]\\n flatnesses = [x.timbre[2] for i, x in enumerate(self.original.analysis.segments)]\\n attacks = [x.timbre[3] for i, x in enumerate(self.original.analysis.segments)]\\n timbre5 = [x.timbre[4] for i, x in enumerate(self.original.analysis.segments)]\\n timbre6 = [x.timbre[5] for i, x in enumerate(self.original.analysis.segments)]\\n timbre7 = [x.timbre[6] for i, x in enumerate(self.original.analysis.segments)]\\n timbre8 = [x.timbre[7] for i, x in enumerate(self.original.analysis.segments)]\\n timbre9 = [x.timbre[8] for i, x in enumerate(self.original.analysis.segments)]\\n timbre10 = [x.timbre[9] for i, x in enumerate(self.original.analysis.segments)]\\n timbre11 = [x.timbre[10] for i, x in enumerate(self.original.analysis.segments)]\\n timbre12 = [x.timbre[11] for i, x in enumerate(self.original.analysis.segments)]\\n\\n print \\\"AVERAGES\\\"\\n print \\\"%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\" % ('loud','bright','flat','attack','t5','t6','t7','t8','t9','t10','t11','t12')\\n print \\\"%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\" % (avg(loudnesses),avg(brightnesses),avg(flatnesses),avg(attacks),avg(timbre5),avg(timbre6),avg(timbre7),avg(timbre8),avg(timbre9),avg(timbre10),avg(timbre11),avg(timbre12))\\n print\\n print \\\"STDVS\\\"\\n print \\\"%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\" % ('loud','bright','flat','attack','t5','t6','t7','t8','t9','t10','t11','t12')\\n print \\\"%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\" % (stddev(loudnesses),stddev(brightnesses),stddev(flatnesses),stddev(attacks),stddev(timbre5),stddev(timbre6),stddev(timbre7),stddev(timbre8),stddev(timbre9),stddev(timbre10),stddev(timbre11),stddev(timbre12))\\n\\n\\n print \\\"\\\\tLoud\\\\tBright\\\\tFlat\\\\tAttack\\\\ttim5\\\\ttim6\\\\ttim7\\\\ttim8\\\\ttim9\\\\ttim10\\\\ttim11\\\\ttim12\\\"\\n for segment in self.original.analysis.segments:\\n if are_kicks(segment): print \\\"Kick\\\",\\n elif are_snares(segment): print \\\"Snar\\\",\\n elif are_hats(segment): print \\\"Hats\\\",\\n else: print \\\"else\\\",\\n print \\\"\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\" % (segment.timbre[0], segment.timbre[1], segment.timbre[2], segment.timbre[3], segment.timbre[4])\\n\\n kicks = self.original.analysis.segments.that(are_kicks)\\n #if kicks: kicks.encode('kicks.mp3')\\n snares = self.original.analysis.segments.that(are_snares)\\n #if snares: snares.encode('snares.mp3')\\n hats = self.original.analysis.segments.that(are_hats)\\n #if hats: hats.encode('hats.mp3')\\n\\n # Time to replace\\n hat_sample = audio.AudioData(self.sample_path + self.template['hats'], sampleRate=44100, numChannels=2, verbose=False)\\n kick_sample = audio.AudioData(self.sample_path + self.template['kick'], sampleRate=44100, numChannels=2, verbose=False)\\n snare_sample = audio.AudioData(self.sample_path + self.template['snare'], sampleRate=44100, numChannels=2, verbose=False)\\n \\n empty = audio.AudioData(ndarray=numpy.zeros(((self.original.sampleRate * self.original.analysis.duration), 2), dtype=numpy.int16), numChannels=2, sampleRate=44100)\\n\\n last = 0\\n for segment in kicks:\\n if last + len(kick_sample.data) > segment.start:\\n print \\\"Adding kick at %s\\\" % segment.start\\n empty.data[self.original.sampleRate*segment.start:self.original.sampleRate*segment.start + len(kick_sample.data)] += kick_sample.data\\n last = segment.start\\n\\n last = 0\\n for segment in snares:\\n if last + len(snare_sample.data) > segment.start:\\n print \\\"Adding snare at %s\\\" % segment.start\\n empty.data[self.original.sampleRate*segment.start:self.original.sampleRate*segment.start + len(snare_sample.data)] += snare_sample.data \\n last = segment.start\\n for segment in hats:\\n if last + len(hat_sample.data) > segment.start:\\n print \\\"Adding hat at %s\\\" % segment.start\\n empty.data[self.original.sampleRate*segment.start:self.original.sampleRate*segment.start + len(hat_sample.data)] += hat_sample.data\\n last = segment.start\\n\\n audio.mix(empty, self.original, 0.5).encode('mixed.mp3')\",\n \"def convert2mel(audio,base_path,fs, n_fft,fmax,n_mels,hop_length_samples, window_lenght,type_training):\\n\\n path = os.path.join(base_path, audio)\\n if type_training != \\\"train\\\":\\n if os.path.isfile(os.path.join(base_path,\\\"processed_wavs_train\\\",audio)):\\n data,_ = librosa.core.load(os.path.join(base_path,\\\"processed_wavs_train\\\",audio), sr=fs, res_type=\\\"kaiser_best\\\")\\n else:\\n data,_ = librosa.core.load(os.path.join(base_path,\\\"processed_wavs_test\\\",audio), sr=fs, res_type=\\\"kaiser_best\\\")\\n else:\\n data, _ = librosa.core.load(path, sr=fs, res_type=\\\"kaiser_best\\\")\\n data = normalize_amplitude(data)\\n\\n powSpectrum = np.abs(stft(data+ 0.00001,n_fft,hop_length = hop_length_samples, win_length = window_lenght, window = windowing(window_lenght, sym=False), center=True, pad_mode='reflect'))**2\\n\\n mels = melspectrogram(y= None,n_fft=n_fft ,sr=fs ,S= powSpectrum, hop_length= hop_length_samples ,n_mels=n_mels,fmax=fmax , fmin = 0.0).T\\n mels = librosa.core.power_to_db(mels, ref=np.min(mels))\\n mels = mels / np.max(mels)\\n\\n return mels.T\",\n \"def convert_and_move_file (filename, origpath, wavpath, mp4path, mono):\\n name, ext = path.splitext(filename)\\n if ext == \\\".mp4\\\":\\n print(filename)\\n convert_to_wav (filename, name, origpath, wavpath, mono)\\n\\n if not path.exists(mp4path):\\n makedirs(mp4path)\\n oldlocation = path.join(origpath, filename)\\n newlocation = path.join(mp4path, filename)\\n shutil.move(oldlocation, newlocation)\",\n \"def convert_text(self):\\n if msg.askyesno(message=\\\"Do you want to save audio file?\\\"):\\n text = self.textbox.get(\\\"1.0\\\", tk.END)\\n self.file.text = text\\n files = [('Sound', '*.mp3')]\\n mp3_file = asksaveasfile(title=\\\"Save your mp3 file\\\", filetypes=files, defaultextension=files)\\n if mp3_file is not None:\\n self.file.convert_text_to_mp3(languages[self.language.get()], mp3_file.name)\\n msg.showinfo(title=\\\"Text to audio\\\", message=\\\"Done\\\")\",\n \"def process_audio_multiprocess(file_paths_arr,\\n filt_type, filt_cutoff_freq, filt_order,\\n trim_margin_left, trim_margin_right, trim_top_db, trim_window_length, trim_hop_length, trim_ref, trim_preemphasis_strength,\\n SAMPLE_RATE=48000, MIN_SAMPLE_RATE=15999, BIT_DEPTH=2,\\n ignore_dirs=[\\\"Noise samples\\\",\\\"_Noisy_\\\",\\\"_Very Noisy_\\\"], skip_existing=False,\\n in_ext_=None, out_ext=\\\".wav\\\", use_tqdm=True, dump_sample_rates=True\\n ):\\n import soundfile as sf\\n import scipy\\n from scipy import signal\\n \\n if dump_sample_rates:\\n sample_rates = {} # array of dicts. e.g: [{path 0: sample_rate 0}, {path 1: sample_rate 1}, {path 2: sample_rate 2}, ...]\\n \\n skip = 0\\n prev_sr = 0\\n iterator = tqdm(file_paths_arr, smoothing=0.0) if use_tqdm else file_paths_arr\\n for file_path in iterator: # recursive directory search\\n in_ext = in_ext_ if (in_ext_ is not None) else os.path.splitext(os.path.split(file_path)[-1])[-1] # get ext from file_path or use override.\\n out_path = file_path.replace(in_ext,out_ext)\\n if skip_existing and os.path.exists(out_path):\\n continue\\n if any([filter_dir in file_path for filter_dir in ignore_dirs]):\\n continue\\n \\n # VCTK cleanup\\n #if file_path.endswith(f\\\"_mic1{in_ext}\\\"):\\n # os.rename(file_path, file_path.replace(f\\\"_mic1{in_ext}\\\",in_ext))\\n #if file_path.endswith(f\\\"_mic2{in_ext}\\\"):\\n # continue\\n try:\\n native_sound, native_SR = sf.read(file_path, always_2d=True)\\n except RuntimeError as ex:\\n print(f'\\\"{os.path.split(file_path)[-1]}\\\" failed to load and has been deleted.\\\\nDELETED PATH: \\\"{file_path}\\\"')\\n os.unlink(file_path)\\n #raise RuntimeError(ex)\\n native_sound = native_sound[:,0]# take first channel (either mono or left audio channel)\\n native_sound = np.asfortranarray(native_sound).astype('float64') # and ensure the audio is contiguous\\n \\n if native_SR < MIN_SAMPLE_RATE: # skip any files with native_SR below the minimum\\n continue\\n if native_SR != SAMPLE_RATE: # ensure all audio is same Sample Rate\\n try:\\n sound = librosa.core.resample(native_sound, native_SR, SAMPLE_RATE)\\n except ValueError as ex:\\n print(ex, file_path, native_SR, len(native_sound), sep=\\\"\\\\n\\\")\\n raise ValueError(ex)\\n else:\\n sound = native_sound\\n \\n if dump_sample_rates:\\n sample_rates[os.path.abspath(out_path)] = native_SR\\n \\n # 24 bit -> 16 bit, 32 bit -> 16 bit\\n if max(np.amax(native_sound), -np.amin(native_sound)) > (2**23): # if samples exceed values possible at 24 bit\\n sound = (sound / 2**(31-15))#.astype('int16') # change bit depth from 32 bit to 16 bit\\n elif max(np.amax(native_sound), -np.amin(native_sound)) > (2**15): # if samples exceed values possible at 16 bit\\n sound = (sound / 2**(23-15))#.astype('int16') # change bit depth from 24 bit to 16 bit\\n \\n # apply audio filters\\n for type_, freq_, order_ in zip(filt_type, filt_cutoff_freq, filt_order): # eg[ ['lp'], [40], [10] ] # i.e [type, freq, strength]\\n sos = signal.butter(order_, freq_, type_, fs=SAMPLE_RATE, output='sos') # calcuate filter somethings\\n sound = signal.sosfilt(sos, sound) # apply filter\\n \\n # apply audio trimming\\n for i, (margin_left_, margin_right_, top_db_, window_length_, hop_length_, ref_, preemphasis_strength_) in enumerate(zip(trim_margin_left, trim_margin_right, trim_top_db, trim_window_length, trim_hop_length, trim_ref, trim_preemphasis_strength)):\\n if preemphasis_strength_:\\n sound_filt = librosa.effects.preemphasis(sound, coef=preemphasis_strength_)\\n _, index = librosa.effects.trim(sound_filt, top_db=top_db_, frame_length=window_length_, hop_length=hop_length_, ref=ref_) # gonna be a little messed up for different sampling rates\\n else:\\n _, index = librosa.effects.trim(sound, top_db=top_db_, frame_length=window_length_, hop_length=hop_length_, ref=ref_) # gonna be a little messed up for different sampling rates\\n try:\\n sound = sound[int(max(index[0]-margin_left_, 0)):int(index[1]+margin_right_)]\\n except TypeError:\\n print(f'Slice Left:\\\\n{max(index[0]-margin_left_, 0)}\\\\nSlice Right:\\\\n{index[1]+margin_right_}')\\n assert len(sound), f\\\"Audio trimmed to 0 length by pass {i+1}\\\\nconfig = {[margin_left_, margin_right_, top_db_, window_length_, hop_length_, ref_]}\\\\nFile_Path = '{file_path}'\\\"\\n \\n # write updated audio to file\\n if os.path.exists(out_path):\\n os.unlink(out_path) # using unlink incase the out_path object is a symlink\\n sf.write(out_path, sound, SAMPLE_RATE)\\n \\n if dump_sample_rates:\\n return sample_rates\",\n \"def text_to_mp3(client: texttospeech.TextToSpeechClient,\\n voice: texttospeech.VoiceSelectionParams,\\n audio_config: texttospeech.AudioConfig,\\n text: str,\\n output_file_path: Path) -> None:\\n lines = text.splitlines()\\n\\n logger.info(f'Synthesising {len(lines)} lines ...')\\n\\n output_file_log = output_file_path.parent / (output_file_path.stem + '_log.json')\\n\\n with output_file_path.open(mode='wb') as output_file:\\n for (i, text_chunk) in enumerate(lines):\\n # skip empty lines\\n if len(text_chunk) > 0:\\n input_text = texttospeech.SynthesisInput(text=text_chunk)\\n try:\\n logger.info(f'Synthesising speech for chunk `{i}`, size: `{len(text_chunk)}`')\\n response = client.synthesize_speech(input=input_text, voice=voice, audio_config=audio_config)\\n except Exception as e:\\n # If a line could not be synthesised properly, return it along with the error message\\n # It is possible that textract could not extract the text properly.\\n logger.error(f'Speech synthesising failed! Chunk text: `{input_text}`\\\\nError: {e}\\\\n')\\n _error_log = {\\n 'chunk_number': i,\\n 'chunk_length': len(text_chunk),\\n 'chunk_text': str(text_chunk),\\n 'Error message': traceback.format_exc()\\n }\\n with open(f'{output_file_log}', 'w') as log_out:\\n json.dump(_error_log, log_out)\\n continue\\n output_file.write(response.audio_content)\\n logger.info(f'Audio content written to `{output_file_path}`!')\\n\\n logger.info(f'Output saved to `{output_file_path}`')\\n logger.info(f'logs at `{output_file_log}`')\",\n \"def save(filename_audio, filename_jam, jam, strict=True, fmt=\\\"auto\\\", **kwargs):\\n\\n y = jam.sandbox.muda._audio[\\\"y\\\"]\\n sr = jam.sandbox.muda._audio[\\\"sr\\\"]\\n\\n # First, dump the audio file\\n psf.write(filename_audio, y, sr, **kwargs)\\n\\n # Then dump the jam\\n jam.save(filename_jam, strict=strict, fmt=fmt)\",\n \"def encode_audio(in_file, out_file):\\r\\n # construct the encoder\\r\\n autoencoder = keras.models.load_model(\\\"audio_autoencoder.model\\\")\\r\\n in_layer = keras.layers.Input(shape=(416, 1))\\r\\n encode = autoencoder.layers[1](in_layer)\\r\\n encode = autoencoder.layers[2](encode)\\r\\n encode = autoencoder.layers[3](encode)\\r\\n encode = autoencoder.layers[4](encode)\\r\\n encode = autoencoder.layers[5](encode)\\r\\n encode = autoencoder.layers[6](encode)\\r\\n encode = autoencoder.layers[7](encode)\\r\\n encode = autoencoder.layers[8](encode)\\r\\n encode = autoencoder.layers[9](encode)\\r\\n encode = autoencoder.layers[10](encode)\\r\\n encode = autoencoder.layers[11](encode)\\r\\n encode = autoencoder.layers[12](encode)\\r\\n encoder = keras.models.Model(in_layer, encode)\\r\\n\\r\\n # Read the file\\r\\n samp_rate, data = wavfile.read(in_file)\\r\\n # check if the file is mono or stereo\\r\\n if len(data.shape) == 2:\\r\\n data = np.concatenate(data)\\r\\n chans = 2\\r\\n else:\\r\\n chans = 1\\r\\n\\r\\n # Rescale integer samples over range [-32768,32767] to floats over range [0.0,1.0]\\r\\n data = data.astype('float32') / float(pow(2, 15))\\r\\n data += 1.0\\r\\n data = data / 2.0\\r\\n\\r\\n # Pad the samples with zeroes, if needed, to make the last encoding frame full\\r\\n padded = np.pad(data, (0, 416 - (len(data) % 416)), 'constant')\\r\\n\\r\\n # Construct input layer\\r\\n inputs = padded.reshape(len(padded) // 416, 416, 1)\\r\\n\\r\\n # Encode the data\\r\\n encoded = encoder.predict(inputs)\\r\\n\\r\\n # Save the encoded data, as well as the important parameters\\r\\n np.savez_compressed(out_file, data=encoded, rate=samp_rate, Type=1, channels=chans)\",\n \"def wav_to_raw(path, log=False):\\n rate, data = wavfile.read(path)\\n if log:\\n m, s = divmod(float(len(data))/rate, 60)\\n h, m = divmod(m, 60)\\n logging.info(\\\"Original recording length: %d h %d m %d s\\\" % (h, m, s))\\n try:\\n if data.shape[1] == 2:\\n # If stereo (2-channel), take the average of the two channels.\\n data = 0.5 * (data[:, 0] + data[:, 1])\\n if log:\\n logging.info('Stereo audio')\\n except IndexError:\\n if log:\\n logging.info('Mono audio')\\n return rate, data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73525465","0.7225452","0.7119044","0.70570403","0.67239785","0.6696764","0.6579686","0.6547333","0.6539131","0.6505683","0.6481485","0.64209044","0.6362076","0.6354701","0.632691","0.6275299","0.62359387","0.6216278","0.6215746","0.61728823","0.6155799","0.6154977","0.61340415","0.6125287","0.61050206","0.60945886","0.6072155","0.60684216","0.60684216","0.60557544","0.6053467","0.604538","0.60409653","0.6027764","0.5987558","0.59873974","0.59644055","0.5963298","0.59589297","0.59359926","0.5931909","0.5915822","0.58688855","0.58459353","0.58223444","0.58203864","0.58193636","0.58147824","0.5812108","0.5777394","0.5773733","0.57648647","0.57339704","0.57298374","0.5728567","0.5728271","0.5708801","0.56893677","0.5678529","0.5664465","0.566363","0.5662083","0.56588143","0.56450695","0.5641505","0.5635191","0.5629698","0.5610478","0.5598876","0.55977076","0.5597488","0.55618393","0.5556827","0.5553541","0.55526215","0.55238634","0.55171514","0.5505199","0.55034196","0.54997575","0.54846406","0.5481474","0.5480482","0.547962","0.5478493","0.54772556","0.5474178","0.54688716","0.54688287","0.5467219","0.5467049","0.54613817","0.5459846","0.54512024","0.5448733","0.5447393","0.5444183","0.5442604","0.5438985","0.5438186"],"string":"[\n \"0.73525465\",\n \"0.7225452\",\n \"0.7119044\",\n \"0.70570403\",\n \"0.67239785\",\n \"0.6696764\",\n \"0.6579686\",\n \"0.6547333\",\n \"0.6539131\",\n \"0.6505683\",\n \"0.6481485\",\n \"0.64209044\",\n \"0.6362076\",\n \"0.6354701\",\n \"0.632691\",\n \"0.6275299\",\n \"0.62359387\",\n \"0.6216278\",\n \"0.6215746\",\n \"0.61728823\",\n \"0.6155799\",\n \"0.6154977\",\n \"0.61340415\",\n \"0.6125287\",\n \"0.61050206\",\n \"0.60945886\",\n \"0.6072155\",\n \"0.60684216\",\n \"0.60684216\",\n \"0.60557544\",\n \"0.6053467\",\n \"0.604538\",\n \"0.60409653\",\n \"0.6027764\",\n \"0.5987558\",\n \"0.59873974\",\n \"0.59644055\",\n \"0.5963298\",\n \"0.59589297\",\n \"0.59359926\",\n \"0.5931909\",\n \"0.5915822\",\n \"0.58688855\",\n \"0.58459353\",\n \"0.58223444\",\n \"0.58203864\",\n \"0.58193636\",\n \"0.58147824\",\n \"0.5812108\",\n \"0.5777394\",\n \"0.5773733\",\n \"0.57648647\",\n \"0.57339704\",\n \"0.57298374\",\n \"0.5728567\",\n \"0.5728271\",\n \"0.5708801\",\n \"0.56893677\",\n \"0.5678529\",\n \"0.5664465\",\n \"0.566363\",\n \"0.5662083\",\n \"0.56588143\",\n \"0.56450695\",\n \"0.5641505\",\n \"0.5635191\",\n \"0.5629698\",\n \"0.5610478\",\n \"0.5598876\",\n \"0.55977076\",\n \"0.5597488\",\n \"0.55618393\",\n \"0.5556827\",\n \"0.5553541\",\n \"0.55526215\",\n \"0.55238634\",\n \"0.55171514\",\n \"0.5505199\",\n \"0.55034196\",\n \"0.54997575\",\n \"0.54846406\",\n \"0.5481474\",\n \"0.5480482\",\n \"0.547962\",\n \"0.5478493\",\n \"0.54772556\",\n \"0.5474178\",\n \"0.54688716\",\n \"0.54688287\",\n \"0.5467219\",\n \"0.5467049\",\n \"0.54613817\",\n \"0.5459846\",\n \"0.54512024\",\n \"0.5448733\",\n \"0.5447393\",\n \"0.5444183\",\n \"0.5442604\",\n \"0.5438985\",\n \"0.5438186\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8660163"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":31,"numItemsPerPage":100,"numTotalItems":95772,"offset":3100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NzczMjcyNCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3Nzc3MzYzMjQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.LcvgvNJZp81-Lxg_VDGiBMD03R2BaET276KzIUmo_cNH1B7NbwmwEgOlZo_p1NXuvhhBs8pjyBltOFTPGqJtAQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Method which calculate Offensive Ratio of a player. The total points scored in 100 possessions | def set_offensive_ratio(self):
bx = self.get_standard_stats()
team = self.get_team_stats()
opp_team = self.get_opp_team_stats()
if bx["minutes"] > 0 and (bx["t2p_int"] + bx["t3p_int"]) > 0:
fgm = bx["t2p_conv"] + bx["t3p_conv"]
fga = bx["t2p_int"] + bx["t3p_int"]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&loc... | [
"0.6951562",
"0.6515817",
"0.644771",
"0.6344681",
"0.62165296",
"0.62093073",
"0.61908257",
"0.6157803",
"0.6073757",
"0.60568166",
"0.6025391",
"0.60042846",
"0.5987803",
"0.5981942",
"0.5976337",
"0.5951976",
"0.5948813",
"0.5936161",
"0.593527",
"0.593107",
"0.5930244",
... | 0.6635203 | 1 |
Linear interpolation for converting between physics and engineering units. | def __init__(self, coef, f1=unit_function, f2=unit_function):
super(self.__class__, self).__init__(f1, f2)
self.p = np.poly1d(coef) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def interpolate_linear(self, transect):\n\n u = np.copy(self.u_mps)\n v = np.copy(self.v_mps)\n\n valid = np.isnan(u) == False\n\n # Check for valid data\n if sum(valid) > 1 and sum(self.valid_data[0, :]) > 1:\n\n # Compute ens_time\n ens_time = np.nancumsum... | [
"0.63465023",
"0.62840116",
"0.6036108",
"0.59930384",
"0.59634036",
"0.59620404",
"0.5953784",
"0.59198254",
"0.5882442",
"0.5880557",
"0.5876995",
"0.5843551",
"0.5801997",
"0.57321805",
"0.5688701",
"0.5683657",
"0.5601913",
"0.55995375",
"0.55786633",
"0.5578463",
"0.5534... | 0.0 | -1 |
Convert between engineering and physics units. | def _raw_eng_to_phys(self, eng_value):
return self.p(eng_value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6",
"def original_units(self):\n self.physical_units(distance=self.infer_original_units('km'),\n velocity=self.infer_original_units('km s^-1'),\n ... | [
"0.6702368",
"0.661202",
"0.6604063",
"0.6344034",
"0.61844754",
"0.6114347",
"0.60904294",
"0.6029163",
"0.6023127",
"0.59929097",
"0.5970022",
"0.59694815",
"0.5943942",
"0.5935189",
"0.59149885",
"0.59114206",
"0.5895953",
"0.5884657",
"0.58838505",
"0.5863761",
"0.5856587... | 0.57462955 | 29 |
Convert between physics and engineering units. | def _raw_phys_to_eng(self, physics_value):
roots = (self.p - physics_value).roots
if len(roots) == 1:
x = roots[0]
return x
else:
raise ValueError("There doesn't exist a corresponding engineering value or "
"they are not unique:", ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6",
"def original_units(self):\n self.physical_units(distance=self.infer_original_units('km'),\n velocity=self.infer_original_units('km s^-1'),\n ... | [
"0.67884886",
"0.65156615",
"0.6370421",
"0.62429684",
"0.60196847",
"0.59708744",
"0.59549516",
"0.59494585",
"0.59487826",
"0.59480655",
"0.591996",
"0.5908836",
"0.590394",
"0.5892939",
"0.58907676",
"0.58825135",
"0.58816415",
"0.5879758",
"0.5878579",
"0.5834652",
"0.580... | 0.60435265 | 4 |
PChip interpolation for converting between physics and engineering units. | def __init__(self, x, y, f1=unit_function, f2=unit_function):
super(self.__class__, self).__init__(f1, f2)
self.x = x
self.y = y
self.pp = PchipInterpolator(x, y)
diff = np.diff(y)
if not ((np.all(diff > 0)) or (np.all((diff < 0)))):
raise ValueError("Given c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _raw_phys_to_eng(self, physics_value):\n y = [val - physics_value for val in self.y]\n new_pp = PchipInterpolator(self.x, y)\n roots = new_pp.roots()\n if len(roots) == 1:\n x = roots[0]\n return x\n else:\n raise UniqueSolutionException(\"The... | [
"0.6409062",
"0.6191294",
"0.6163329",
"0.60624963",
"0.59122026",
"0.591134",
"0.5853295",
"0.57724625",
"0.5744279",
"0.57384187",
"0.5700157",
"0.5695096",
"0.56918746",
"0.56765395",
"0.56729674",
"0.56695503",
"0.56321025",
"0.5626728",
"0.56115127",
"0.5593795",
"0.5577... | 0.0 | -1 |
Convert between engineering and physics units. | def _raw_eng_to_phys(self, eng_value):
return self.pp(eng_value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6",
"def original_units(self):\n self.physical_units(distance=self.infer_original_units('km'),\n velocity=self.infer_original_units('km s^-1'),\n ... | [
"0.6702368",
"0.661202",
"0.6604063",
"0.6344034",
"0.61844754",
"0.6114347",
"0.60904294",
"0.6029163",
"0.6023127",
"0.59929097",
"0.5970022",
"0.59694815",
"0.5943942",
"0.5935189",
"0.59149885",
"0.59114206",
"0.5895953",
"0.5884657",
"0.58838505",
"0.5863761",
"0.5856587... | 0.5688327 | 32 |
Convert between physics and engineering units. | def _raw_phys_to_eng(self, physics_value):
y = [val - physics_value for val in self.y]
new_pp = PchipInterpolator(self.x, y)
roots = new_pp.roots()
if len(roots) == 1:
x = roots[0]
return x
else:
raise UniqueSolutionException("The function does... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6",
"def original_units(self):\n self.physical_units(distance=self.infer_original_units('km'),\n velocity=self.infer_original_units('km s^-1'),\n ... | [
"0.67884886",
"0.65156615",
"0.6370421",
"0.62429684",
"0.60435265",
"0.60196847",
"0.59708744",
"0.59549516",
"0.59494585",
"0.59487826",
"0.59480655",
"0.591996",
"0.5908836",
"0.590394",
"0.5892939",
"0.58907676",
"0.58825135",
"0.58816415",
"0.5879758",
"0.5878579",
"0.58... | 0.0 | -1 |
This function is used to make the final dataset to be used, computes and adds the new WsRF and service classification | def make_dataset(interim_file_path, processed_file_path, weights, version):
qws_wsrf, qws_complete_numpy_array = src.dataset.compute_wsrf.compute_wsrf(interim_file_path, weights)
# qws_complete_numpy_array_temp = np.append(qws_complete_numpy_array, qws_wsrf[:, np.newaxis], axis=1)
qws_wsrf_level = np.array(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __train__(self):\n if (self.type_camf == 'CAMF_CI'):\n #users, items, context, ratings\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = ci.fit()\n ... | [
"0.66069067",
"0.66063356",
"0.6386136",
"0.63641405",
"0.6359857",
"0.6340846",
"0.63389325",
"0.63323617",
"0.6254566",
"0.62452006",
"0.6183691",
"0.61397463",
"0.61367977",
"0.6132934",
"0.61155736",
"0.6114331",
"0.6066086",
"0.6050593",
"0.60490036",
"0.6045469",
"0.603... | 0.6155825 | 11 |
Return the serializer instance that should be used for validating and deserializing input, and for serializing output. | def get_serializer_in(self, *args, **kwargs):
serializer_class = self.get_serializer_class_in()
kwargs['context'] = self.get_serializer_context()
return serializer_class(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSerializer():",
"def get_serializer(self, *args, **kwargs):\n serializer_class = self.get_serializer_class()\n kwargs['context'] = self.get_serializer_context()\n return serializer_class(*args, **kwargs)",
"def serializer_for(self, obj):\n # 1-NULL serializer\n if obj ... | [
"0.72009987",
"0.7115752",
"0.69366866",
"0.6924428",
"0.68449354",
"0.6820688",
"0.67195165",
"0.6692233",
"0.6686074",
"0.65120816",
"0.6473344",
"0.6473284",
"0.6444412",
"0.6443525",
"0.6418904",
"0.63524395",
"0.6348317",
"0.63381505",
"0.6311651",
"0.63109744",
"0.62789... | 0.67095476 | 7 |
Do login action here. For example in case of session authentication store the session in cookies. | def do_login(self, backend, user): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login(self):\n\n self.__login_if_required()",
"def login(self):\n if self._cookie_cached(self.login_email):\n self.cookie_login(self.login_email)\n else:\n self.new_login(self.login_email, self.login_pass)",
"def login_perform():\n try:\n user_name = req... | [
"0.7799108",
"0.7728997",
"0.7510619",
"0.7478229",
"0.7478229",
"0.7477876",
"0.74192667",
"0.7330238",
"0.7261792",
"0.72554547",
"0.72398543",
"0.7227756",
"0.7222385",
"0.7211491",
"0.7187431",
"0.71860313",
"0.7163313",
"0.7160891",
"0.7127272",
"0.7124372",
"0.71183175"... | 0.7133062 | 18 |
auth_data will be used used as request_data in strategy | def set_input_data(self, request, auth_data):
request.auth_data = auth_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_oauth_data():",
"def __init__(self, my_data, my_auth):\n self.user = my_auth.user\n self.password = my_auth.password\n self.my_data = my_data",
"def authenticate(self, request):\n auth_data = super().authenticate(request)\n if not auth_data:\n return auth_d... | [
"0.6669421",
"0.6569925",
"0.63427466",
"0.61100876",
"0.6065976",
"0.6054941",
"0.6029151",
"0.60213995",
"0.6012752",
"0.5897798",
"0.5737002",
"0.5730088",
"0.56567615",
"0.5615505",
"0.56064767",
"0.55513734",
"0.5519616",
"0.5500598",
"0.5468376",
"0.5468376",
"0.5440677... | 0.71807003 | 0 |
Tests that only 'admin' can add a product | def test_only_admin_can_create_product(self):
resp = self.admin_create_user()
reply = self.attendant_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_non_admin_cannot_delete_product(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n )\n re... | [
"0.7732614",
"0.766534",
"0.746467",
"0.73577404",
"0.7302724",
"0.7297793",
"0.7198699",
"0.7088031",
"0.706756",
"0.69749635",
"0.6925475",
"0.6893543",
"0.6830343",
"0.68255603",
"0.6805827",
"0.68006784",
"0.677526",
"0.67369896",
"0.6678268",
"0.66471297",
"0.6601341",
... | 0.8407797 | 0 |
Tests that 'admin' can add a product | def test_admin_create_product(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.client.post(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_only_admin_can_create_product(self):\n resp = self.admin_create_user()\n reply = self.attendant_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n )\n ... | [
"0.8125268",
"0.78284925",
"0.7689276",
"0.74345493",
"0.7312975",
"0.72979146",
"0.71163535",
"0.709621",
"0.70959914",
"0.7021732",
"0.6964215",
"0.6953487",
"0.6913336",
"0.6887993",
"0.6846328",
"0.6843517",
"0.6843496",
"0.68297696",
"0.67998624",
"0.6782752",
"0.6768684... | 0.79675835 | 1 |
Test admin cannot create a product with a blacklisted token | def test_cannot_create_product_with_blacklisted_token(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
resp = self.client.delete(
'/api/v1/logout',
headers={'Authorization': 'Bearer {}'.format(token)}
)
reply =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cannot_view_a_product_with_blacklisted_token(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n ... | [
"0.82479733",
"0.7897591",
"0.7884179",
"0.78223985",
"0.7625364",
"0.7585557",
"0.7400365",
"0.7375994",
"0.72420007",
"0.7152579",
"0.7103639",
"0.70389014",
"0.6944365",
"0.6929796",
"0.68858266",
"0.68301815",
"0.67753994",
"0.6750073",
"0.6746582",
"0.66715974",
"0.66688... | 0.8788049 | 0 |
Tests that 'admin' cannot add a product with empty fields | def test_admin_cannot_create_product_with_empty_fields(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='',
category='',
stock=20,
price=150
)
resp = self.client... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cannot_make_sale_with_missing_fields(self):\n reply = self.admin_add_product()\n\n resp = self.admin_create_user()\n reply = self.attendant_login()\n token = reply['token']\n sale = dict(products = [\n {\n \"prod_name\":\"\", \n \... | [
"0.7727357",
"0.71426547",
"0.71228373",
"0.6888725",
"0.6875848",
"0.68659735",
"0.68113697",
"0.6800745",
"0.6779112",
"0.67721987",
"0.6709652",
"0.66885155",
"0.6665036",
"0.6651361",
"0.6607132",
"0.66057837",
"0.66039413",
"0.65725106",
"0.6552758",
"0.6544897",
"0.6522... | 0.8373025 | 0 |
Tests that product_name field cannot contain a number | def test_Product_name_cannot_contain_a_number(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_3',
category='denims',
stock=20,
price=150
)
resp = self.clien... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_category_cannot_contain_a_number(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='4dens',\n stock=20,\n price=150\n )\n re... | [
"0.6742002",
"0.6642998",
"0.6555487",
"0.6555487",
"0.6454647",
"0.62910545",
"0.62258327",
"0.6198766",
"0.6166252",
"0.61075205",
"0.5994341",
"0.5968352",
"0.5964386",
"0.595047",
"0.5949145",
"0.5943742",
"0.59381294",
"0.591026",
"0.5901904",
"0.5901547",
"0.58894527",
... | 0.76176125 | 0 |
Tests that category field cannot contain a number | def test_category_cannot_contain_a_number(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='4dens',
stock=20,
price=150
)
resp = self.clien... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_isNumericCategory(self):\r\n obs = self.overview_map.isNumericCategory('Treatment')\r\n self.assertEqual(obs, False)\r\n\r\n obs = self.overview_map.isNumericCategory('DOB')\r\n self.assertEqual(obs, True)",
"def test_isNumericCategory(self):\n obs = self.overview_map.... | [
"0.69292754",
"0.6892475",
"0.68267983",
"0.68267983",
"0.6329393",
"0.60511804",
"0.6026339",
"0.60021937",
"0.5988064",
"0.5981536",
"0.5980512",
"0.5917058",
"0.59100056",
"0.59020984",
"0.5897836",
"0.5872285",
"0.58462423",
"0.58406997",
"0.58369875",
"0.58208215",
"0.58... | 0.70390165 | 0 |
Tests that stock and price fields must be numbers | def test_stock_and_price_must_be_numbers(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock='stock',
price='money'
)
resp = s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_add_sale_with_price_not_digit_format(self):\n self.register_admin_test_account()\n token = self.login_admin_test()\n\n response = self.app_test_client.post('{}/saleorder'.format(\n self.base_url), json={'name': \"Hand Bag\", 'price': \"1500\", 'quantity': 3, 'totalamt': \"\... | [
"0.73344076",
"0.72246283",
"0.72246283",
"0.68624747",
"0.66491514",
"0.6644348",
"0.66039526",
"0.65944123",
"0.6510274",
"0.64985764",
"0.6415647",
"0.6365934",
"0.6306292",
"0.6289345",
"0.6277049",
"0.6271073",
"0.62253267",
"0.6222383",
"0.6221313",
"0.616871",
"0.61683... | 0.7861267 | 0 |
Tests that product already exists in the Inventory | def test_product_exists_in_inventory(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.client.po... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_view_product_that_doesnot_exist_in_inventory(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n ... | [
"0.7496905",
"0.7326862",
"0.71235555",
"0.68696725",
"0.6750119",
"0.6638737",
"0.65924627",
"0.6544556",
"0.65392476",
"0.6516768",
"0.6488533",
"0.6471995",
"0.64518577",
"0.6451675",
"0.64378035",
"0.63537824",
"0.6353224",
"0.63370115",
"0.6325946",
"0.6315863",
"0.63116... | 0.81727195 | 0 |
Tests that a user can view a product in the Inventory | def test_view_a_product(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.client.post(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_is_product_show(self):\n\n self.selenium.get(\"http://localhost:8000/\")\n response = self.selenium.find_element(By.ID, \"id_product_name\")\n response.send_keys(\"frosties\")\n response.send_keys(Keys.ENTER)\n self.assertTemplateUsed('selected_product.html')",
"def te... | [
"0.6914857",
"0.68370014",
"0.68132645",
"0.67801803",
"0.6777728",
"0.6743917",
"0.67292273",
"0.6651706",
"0.663699",
"0.6590794",
"0.6579514",
"0.654358",
"0.6536533",
"0.64720875",
"0.64325994",
"0.6371396",
"0.63542134",
"0.63323015",
"0.6293569",
"0.6277347",
"0.6251508... | 0.74070454 | 0 |
Tests that a user cannot view a product in the Inventory with blacklisted token | def test_cannot_view_a_product_with_blacklisted_token(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cannot_view_all_products_with_blacklisted_token(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n ... | [
"0.77314836",
"0.7319002",
"0.68258417",
"0.6709656",
"0.66352224",
"0.6600747",
"0.65926576",
"0.65914124",
"0.6580106",
"0.6573959",
"0.6558386",
"0.65569514",
"0.6534714",
"0.6512719",
"0.6504638",
"0.64704",
"0.6448948",
"0.6437487",
"0.6420581",
"0.6419264",
"0.63966596"... | 0.79721093 | 0 |
Tests that a user can view all products in the Inventory | def test_view_all_products(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.client.post(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_products_logged_in(self):\n\n # Log in seller\n self.client.login(username=\"test_seller\", password=\"secret\")\n\n # Issue a GET request\n response = self.client.get(reverse('website:products'))\n\n # Check that the response is 200\n self.assertEqual(respon... | [
"0.72330284",
"0.71533865",
"0.70860183",
"0.6867175",
"0.6790764",
"0.67349434",
"0.6666839",
"0.6636514",
"0.66316766",
"0.6597527",
"0.65619427",
"0.6444273",
"0.6425292",
"0.642249",
"0.6402104",
"0.64012486",
"0.6383176",
"0.6383148",
"0.6321953",
"0.6320072",
"0.6299333... | 0.7486654 | 0 |
Tests that a user cannot view all products in the Inventory with blacklisted token | def test_cannot_view_all_products_with_blacklisted_token(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cannot_view_a_product_with_blacklisted_token(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n ... | [
"0.77733105",
"0.7087671",
"0.67957276",
"0.6761181",
"0.675135",
"0.67509085",
"0.66980356",
"0.6541592",
"0.65259844",
"0.6448291",
"0.64465666",
"0.6436873",
"0.64326245",
"0.64205766",
"0.6409761",
"0.6387554",
"0.6384848",
"0.6369056",
"0.63571316",
"0.63104194",
"0.6281... | 0.8038467 | 0 |
Tests that a user cannot view a product that doesnot exist in the Inventory | def test_view_product_that_doesnot_exist_in_inventory(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cannot_sale_nonexistant_product(self):\n reply = self.admin_add_product()\n\n resp = self.admin_create_user()\n reply = self.attendant_login()\n token = reply['token']\n sale = dict(products = [\n {\n \"prod_name\":\"Paris_heels\", \n ... | [
"0.72640157",
"0.6747577",
"0.6742351",
"0.6686189",
"0.66764927",
"0.6665994",
"0.6556591",
"0.6439238",
"0.6401339",
"0.6370489",
"0.6360187",
"0.6351575",
"0.6346178",
"0.63409466",
"0.63361067",
"0.6330177",
"0.6312651",
"0.62697184",
"0.6259748",
"0.62596893",
"0.6218498... | 0.73303914 | 0 |
Tests that a user cannot view products from empty Inventory | def test_view_products_from_empty_inventory(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
resp = self.client.get(
'/api/v1/products',
headers={'Authorization': 'Bearer {}'.format(token)}
)
reply = json.loads... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_admin_cannot_delete_product_from_empty_Inventory(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n \n resp = self.client.delete(\n '/api/v1/products/1',\n content_type='application/json',\n head... | [
"0.74154675",
"0.72096145",
"0.7158583",
"0.693217",
"0.6781853",
"0.6733253",
"0.66969836",
"0.65152705",
"0.64797616",
"0.64615333",
"0.6445138",
"0.6428424",
"0.63962966",
"0.6393635",
"0.63872916",
"0.63662773",
"0.633816",
"0.6332057",
"0.63152456",
"0.6308194",
"0.63058... | 0.78474796 | 0 |
Tests that a user cannot view a product with invalid id | def test_view_product_with_invalid_id(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.client.p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_detail_odd_product_id_permission(self):\n self.assertEqual(self.product_2.id, 2)\n\n token = Token.objects.create(user=self.user_1)\n headers = {\n 'HTTP_AUTHORIZATION': 'Token ' + str(token)\n }\n response = self.client.get(\n '/api/products/{}/'.f... | [
"0.7096591",
"0.6907471",
"0.6797254",
"0.6654126",
"0.665064",
"0.6630695",
"0.6613442",
"0.6613442",
"0.6613442",
"0.66119534",
"0.65806687",
"0.6550584",
"0.6499338",
"0.64979565",
"0.64979565",
"0.64979565",
"0.6494183",
"0.64578736",
"0.64060956",
"0.63708884",
"0.634357... | 0.75562716 | 0 |
Test that product can be updated successfully | def test_update_product(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.client.post(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_full_update_product(self):\n view = ProductUpdateView.as_view({'patch': 'update'})\n uri = reverse('products:update-product', kwargs={'pk': self.product_id})\n data = {\n \"id\": self.product_id,\n \"name\": \"Headphone updated\",\n \"description\": \"... | [
"0.8304104",
"0.8161559",
"0.8123623",
"0.8105165",
"0.809037",
"0.79182774",
"0.790087",
"0.78989977",
"0.7809965",
"0.7688704",
"0.7684496",
"0.7684496",
"0.7684496",
"0.76524705",
"0.7631343",
"0.76261145",
"0.7580674",
"0.7554157",
"0.75375104",
"0.7501177",
"0.7474084",
... | 0.81104404 | 3 |
Test that product cannot be updated successfully with blacklisted token | def test_cannot_update_product_with_blacklisted_token(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cannot_create_product_with_blacklisted_token(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n\n resp = self.client.delete(\n '/api/v1/logout',\n headers={'Authorization': 'Bearer {}'.format(token)}\n )\n ... | [
"0.7377064",
"0.7333218",
"0.7190565",
"0.7068335",
"0.70310974",
"0.69859517",
"0.67677313",
"0.6604328",
"0.65338165",
"0.65273803",
"0.6446804",
"0.6441972",
"0.64315784",
"0.64071953",
"0.6401291",
"0.6390641",
"0.6355562",
"0.6326239",
"0.6304661",
"0.62910193",
"0.62794... | 0.80966264 | 0 |
Test that you cant updated a nonexistant product | def test_update_nonexistant_product(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product_update = dict(
prod_name='NY_jeans',
category='denims',
stock=50,
price=180
)
resp = self.clie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_nonexist(self):\n promotion = PromotionFactory()\n promotion.id = '1cak41-nonexist'\n try:\n promotion.update()\n except KeyError:\n self.assertRaises(KeyError)",
"def test_update_not_my_product(self):\n post_data = {\n \"categor... | [
"0.74883664",
"0.74142987",
"0.7132973",
"0.7130076",
"0.6898503",
"0.6843232",
"0.676572",
"0.6739922",
"0.67206293",
"0.67113554",
"0.66875863",
"0.6684773",
"0.668369",
"0.66656035",
"0.6630668",
"0.6606419",
"0.65949506",
"0.6585263",
"0.65486664",
"0.65191656",
"0.651270... | 0.7994515 | 0 |
Test that product cannot be updated with unauthorised user | def test_unauthorized_product_update(self):
resp = self.admin_create_user()
reply = self.attendant_login()
token = reply['token']
product_update = dict(
prod_name='NY_jeans',
category='denims',
stock=50,
price=180
)
resp = s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_not_my_product(self):\n post_data = {\n \"category\": {\n \"name\": \"general\",\n \"index\": 0\n },\n \"name\": \"Producto 2 modified\",\n \"description\": \"Descripcion de producto 2 modified\",\n \"sellin... | [
"0.7472202",
"0.74601954",
"0.730332",
"0.72697306",
"0.71795666",
"0.71784",
"0.7131658",
"0.70938385",
"0.7079321",
"0.6975282",
"0.695774",
"0.6886112",
"0.68209416",
"0.68174875",
"0.6791423",
"0.6772019",
"0.6765322",
"0.6752393",
"0.67434675",
"0.66997343",
"0.6691479",... | 0.80988926 | 0 |
Test that product cannot be updated with empty fields | def test_update_product_with_empty_fields(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.clie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_product_required_fields(self):\n data = {\n 'pk': 1,\n 'name': None,\n 'description': '''\n Yogurt also spelled yoghurt, yogourt or yoghourt,\n is a food produced by bacterial fermentation of milk.\n '''\n }\n ... | [
"0.802753",
"0.7568224",
"0.7292608",
"0.7203753",
"0.7033387",
"0.69645137",
"0.6949159",
"0.6943705",
"0.69149756",
"0.691329",
"0.690093",
"0.6899394",
"0.6895893",
"0.68875086",
"0.6824652",
"0.6816774",
"0.68002254",
"0.6785967",
"0.6772013",
"0.67623484",
"0.6751942",
... | 0.8045699 | 0 |
Test that product cannot be updated with numbers for strings | def test_update_product_with_numbers_for_strings(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_non_numberic_validation(self):",
"def test_non_numberic_validation(self):",
"def test_update_product_with_characters_for_numbers(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',... | [
"0.6655952",
"0.6655952",
"0.62706953",
"0.62572986",
"0.6155536",
"0.60939926",
"0.6081916",
"0.60734576",
"0.6025201",
"0.5992067",
"0.5951248",
"0.5883255",
"0.58490777",
"0.5848731",
"0.58472234",
"0.5843898",
"0.5835155",
"0.5830356",
"0.57858956",
"0.57778364",
"0.57684... | 0.6393195 | 2 |
Test that product cannot be updated with strings for numbers | def test_update_product_with_characters_for_numbers(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_non_numberic_validation(self):",
"def test_non_numberic_validation(self):",
"def test_product(self):\n self.assertEqual(functions.product(2, 2), 4)\n self.assertEqual(functions.product(2, -2), -4)",
"def test_update_product_with_numbers_for_strings(self):\n resp = self.admin_reg... | [
"0.6562785",
"0.6562785",
"0.6329283",
"0.6300493",
"0.62892044",
"0.62012047",
"0.6175202",
"0.61220795",
"0.60739857",
"0.6057926",
"0.6026264",
"0.6014248",
"0.60098",
"0.5888831",
"0.5833497",
"0.5802217",
"0.5802217",
"0.57738906",
"0.57637155",
"0.57532704",
"0.5741166"... | 0.62037754 | 5 |
Test that admin can delete a product | def test_admin_delete_product(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.client.post(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_non_admin_cannot_delete_product(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n )\n re... | [
"0.83574384",
"0.83247185",
"0.8285091",
"0.82623804",
"0.8177644",
"0.8141131",
"0.80846477",
"0.80198777",
"0.8002211",
"0.7932145",
"0.7909494",
"0.7733621",
"0.7691911",
"0.7655855",
"0.756794",
"0.7516048",
"0.75010175",
"0.7476865",
"0.74705225",
"0.7435304",
"0.7377097... | 0.8554349 | 0 |
Test that admin can delete a product | def test_admin_cannot_delete_product_with_blacklisted_token(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_admin_delete_product(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n )\n resp = self.c... | [
"0.8554349",
"0.83574384",
"0.83247185",
"0.8285091",
"0.82623804",
"0.8177644",
"0.8141131",
"0.80846477",
"0.80198777",
"0.8002211",
"0.7932145",
"0.7909494",
"0.7691911",
"0.7655855",
"0.756794",
"0.7516048",
"0.75010175",
"0.7476865",
"0.74705225",
"0.7435304",
"0.7377097... | 0.7733621 | 12 |
Test that a non admin cannot delete a product | def test_non_admin_cannot_delete_product(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = self.clien... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_not_my_product(self):\n self._require_login(self.user1)\n response = self.client.delete('/api/1.0/products/2/')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)",
"def test_admin_cannot_delete_nonexistant_product(self):\n resp = self.admin_register()... | [
"0.8456681",
"0.82070416",
"0.8153313",
"0.772525",
"0.750598",
"0.75052166",
"0.7497598",
"0.74397874",
"0.73591393",
"0.7334757",
"0.7330903",
"0.72217363",
"0.72114277",
"0.71953607",
"0.7125004",
"0.70727336",
"0.70629984",
"0.6935391",
"0.69298255",
"0.6893835",
"0.68860... | 0.834971 | 1 |
Test that admin cannnot delete a product from empty Inventory | def test_admin_cannot_delete_product_from_empty_Inventory(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
resp = self.client.delete(
'/api/v1/products/1',
content_type='application/json',
headers={'Authori... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_admin_cannot_delete_nonexistant_product(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n )\n ... | [
"0.79532677",
"0.7735564",
"0.7528131",
"0.7521453",
"0.7518936",
"0.746801",
"0.7354772",
"0.72263944",
"0.71801",
"0.71784055",
"0.7171436",
"0.7112214",
"0.7106493",
"0.70771635",
"0.6879483",
"0.68655676",
"0.68639493",
"0.68453324",
"0.6812393",
"0.6777014",
"0.67697865"... | 0.8764794 | 0 |
Test that admin cannnot delete a nonexistant product | def test_admin_cannot_delete_nonexistant_product(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
resp = se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_not_my_product(self):\n self._require_login(self.user1)\n response = self.client.delete('/api/1.0/products/2/')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)",
"def test_non_admin_cannot_delete_product(self):\n resp = self.admin_register()\n ... | [
"0.8434453",
"0.81416374",
"0.8129146",
"0.79895574",
"0.7884565",
"0.7712441",
"0.7642063",
"0.75856626",
"0.7577927",
"0.757099",
"0.7507489",
"0.75073075",
"0.75018024",
"0.7473333",
"0.7418871",
"0.7409584",
"0.72817427",
"0.7275699",
"0.72678584",
"0.7262097",
"0.7227959... | 0.8506851 | 0 |
Test that admin cannnot delete a product with nointeger prod_id | def test_admin_cannot_delete_product_with_non_integer_prod_id(self):
resp = self.admin_register()
reply = self.admin_login()
token = reply['token']
product = dict(
prod_name='NY_denims',
category='denims',
stock=20,
price=150
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_03_product_delete(self):\n product = self.create_product()\n products = self.product_obj.search([])\n self.assertIn(product, products)\n product.unlink()\n self.assertNotIn(product.exists(), products)",
"def test_delete_not_my_product(self):\n self._require_logi... | [
"0.8163337",
"0.811003",
"0.80877143",
"0.80876744",
"0.8045905",
"0.79786986",
"0.7882516",
"0.7854732",
"0.7846621",
"0.7829516",
"0.77844703",
"0.77800816",
"0.7772745",
"0.77263916",
"0.7600396",
"0.7597553",
"0.75532126",
"0.7346543",
"0.72736114",
"0.7209453",
"0.708175... | 0.8068848 | 4 |
Test ComBat feature harmonization. | def test_combat():
# Check if example data directory exists
example_data_dir = th.find_exampledatadir()
# Check if example data required exists
features = glob.glob(os.path.join(example_data_dir, 'examplefeatures_Patient*.hdf5'))
if len(features) < 7:
message = 'Too few example features for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_feature(feature, value, good_features):\r\n\tbase_write(good_features,\"bin/stanford-ner-2015-04-20/base.prop\")\r\n\tbase_prop = open(\"bin/stanford-ner-2015-04-20/base.prop\", \"a\")\r\n\tbase_prop.write(feature.strip() + \"=\" + str(value) + \"\\n\")\r\n\tbase_prop.close()\r\n\r\n\t#Test read base.prop... | [
"0.652699",
"0.64427763",
"0.6373243",
"0.6333925",
"0.6331873",
"0.6215436",
"0.6211196",
"0.59231627",
"0.59107846",
"0.5880464",
"0.5870288",
"0.58623254",
"0.58284056",
"0.58262885",
"0.58067703",
"0.5803254",
"0.57745475",
"0.5774168",
"0.57514584",
"0.5704505",
"0.57006... | 0.6563471 | 0 |
Test ComBat feature harmonization. | def test_combat_fastr():
# Check if example data directory exists
example_data_dir = th.find_exampledatadir()
# Check if example data required exists
features = glob.glob(os.path.join(example_data_dir, 'examplefeatures_Patient*.hdf5'))
if len(features) < 6:
message = 'Too few example featur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_combat():\n # Check if example data directory exists\n example_data_dir = th.find_exampledatadir()\n\n # Check if example data required exists\n features = glob.glob(os.path.join(example_data_dir, 'examplefeatures_Patient*.hdf5'))\n if len(features) < 7:\n message = 'Too few example ... | [
"0.6563471",
"0.652699",
"0.64427763",
"0.6373243",
"0.6333925",
"0.6331873",
"0.6215436",
"0.6211196",
"0.59107846",
"0.5880464",
"0.5870288",
"0.58623254",
"0.58284056",
"0.58262885",
"0.58067703",
"0.5803254",
"0.57745475",
"0.5774168",
"0.57514584",
"0.5704505",
"0.570060... | 0.59231627 | 8 |
Returns true for all hostclasses which aren't tagged as nonZDD hostclasses | def is_deployable(self, hostclass):
return ((hostclass in self._hostclasses and
is_truthy(self._hostclasses[hostclass].get("deployable"))) or
hostclass not in self._hostclasses) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def IsNoHost(self):\n if self.no_host:\n return True\n return any([node.no_host for node in self.GetAncestorGroups()])",
"def is_opaque(self, classobj):\n try:\n return self.instance_vars[classobj] == []\n except KeyError:\n return False",
"def has_ghosts(self):\n... | [
"0.6732368",
"0.61149806",
"0.60162634",
"0.598662",
"0.5910872",
"0.57612085",
"0.5761027",
"0.5724565",
"0.57139426",
"0.56720996",
"0.56686395",
"0.5650766",
"0.5641392",
"0.56388974",
"0.5596937",
"0.55439645",
"0.55356926",
"0.5530277",
"0.55288005",
"0.5514988",
"0.5490... | 0.66115427 | 1 |
Returns the integration test for this hostclass, or None if none exists | def get_integration_test(self, hostclass):
return (hostclass in self._hostclasses and
self._hostclasses[hostclass].get("integration_test")) or None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_test(self,test_id):\n for test in self.suite.get_tests():\n if test.id == test_id:\n return test\n return None",
"def GetHWTestSuite(self):\n hw_tests = self._run.config['hw_tests']\n if not hw_tests:\n # TODO(milleral): Add HWTests back to lumpy-chrome-... | [
"0.6346583",
"0.6162359",
"0.5884836",
"0.5876703",
"0.55224764",
"0.5468428",
"0.5372038",
"0.529812",
"0.52784747",
"0.52683514",
"0.5250328",
"0.52476835",
"0.5240323",
"0.5180137",
"0.51473355",
"0.51330215",
"0.51204187",
"0.5118088",
"0.5116481",
"0.50992554",
"0.508809... | 0.8695572 | 0 |
Promote AMI to specified stage. And, conditionally, make executable by production account if ami is staged as tested. | def _promote_ami(self, ami, stage):
prod_baker = self._disco_bake.option("prod_baker")
promote_conditions = [
stage == "tested",
prod_baker,
ami.tags.get("baker") == prod_baker,
]
try:
self._disco_bake.promote_ami(ami, stage)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stage(self, stage: osbuild.Stage):",
"def deploy():\n stage(branch='live', role='live')",
"def setup(self, stage: Optional[str] = None) -> None:",
"def deploy():\n test()\n if not env.is_staging:\n backup()\n prepare()\n restart_api()",
"def Stage(self, descriptor, app_dir, runtim... | [
"0.600044",
"0.58983445",
"0.5597183",
"0.55506766",
"0.55401236",
"0.5401714",
"0.5389094",
"0.53601116",
"0.5331389",
"0.52924347",
"0.526997",
"0.52426094",
"0.5238283",
"0.5174726",
"0.5095269",
"0.5092394",
"0.50896496",
"0.5085712",
"0.5071455",
"0.50698596",
"0.5068133... | 0.7794168 | 0 |
Define data used in test. | def setUp(self):
pwd = self.get_script_path()
self.test_drug_info_file = pwd+'/../insight_testsuite/tests/my_test/input/test_input_file.txt'
self.test_raw_tuple= [('jordanmichael', 'A', 23.00),
('jameslebron', 'C', 23.10),
('bryantkobe', 'B', 8),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUpTestData(cls):\n data_gen.run()",
"def setUpTestData(cls):\n data_gen.run()",
"def setUpTestData(cls):\n data_gen.run()",
"def setUpTestData(cls):\n data_gen.run()",
"def setUp(self):\n\n self.data_list = [\n \"hello\", \"world\", \"funilrys\", \"funce... | [
"0.7128387",
"0.7128387",
"0.7128387",
"0.7128387",
"0.6960889",
"0.6884261",
"0.68240964",
"0.68195206",
"0.6783465",
"0.6741896",
"0.6734708",
"0.6721453",
"0.6721293",
"0.67041653",
"0.6678538",
"0.66765255",
"0.6659576",
"0.6627872",
"0.66132146",
"0.66129124",
"0.6599503... | 0.0 | -1 |
Line is correctlt split and missing/corrupetd fields are checked. | def test_read_line(self):
expected_data = ['\"lu, jr\"','ming-yuan','\"DRUG,1\"',135.999,True,3]
input_string = '001,\"LU, JR\",MING-YUAN,\"DRUG,1\",135.999\n'
data = read_line(input_string)
self.assertEqual(expected_data[0],data[0])
self.assertEqual(expected_data[1],data[1])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_Lines(self):\n\n pass",
"def check_record(idline,nclline,sepline,qualiline):\n return check_idline(idline) and check_sepline(sepline)",
"def is_line(self): \n return False",
"def check_line(self):\n if not self.hosts and not self.line:\n self.msg(\"There is... | [
"0.68945944",
"0.65980923",
"0.64360386",
"0.64280456",
"0.640811",
"0.6315471",
"0.62812597",
"0.6233146",
"0.61786985",
"0.617687",
"0.6170383",
"0.61697614",
"0.6118626",
"0.6044029",
"0.6039419",
"0.6007905",
"0.60070646",
"0.6002585",
"0.5974007",
"0.5965619",
"0.5962297... | 0.6924609 | 0 |
Inpue file is correctly read and tuple constructed. | def test_read_input_file(self):
test_max_digit = 2
tuple1 = self.test_raw_tuple
tuple2, max_digit = read_input_file(self.test_drug_info_file)
self.assertEqual(tuple1, tuple2)
self.assertAlmostEqual(max_digit,test_max_digit) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse(self, infile):\r\n raise NotImplementedError()",
"def _read_input_file(self):\n pass",
"def _parse(self, infile):\n raise NotImplementedError()",
"def _read(self, in_file):\n #\n # I know this function is long, but the FRD block is long as well...\n # Splitting... | [
"0.62718296",
"0.6199125",
"0.6139345",
"0.61193955",
"0.60940003",
"0.59377885",
"0.59339136",
"0.5890041",
"0.5879968",
"0.5824287",
"0.5814559",
"0.5812669",
"0.57651573",
"0.5727909",
"0.5723036",
"0.57121086",
"0.570808",
"0.57077694",
"0.5688802",
"0.5678212",
"0.567730... | 0.6141999 | 2 |
Unique drug list dict is correctly returned. | def test_get_unique_drug_list(self):
dict1 = self.test_dict
dict2 = get_unique_drug_list(self.test_sorted_tuple)
self.assertEqual(dict1, dict2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unique_drugs(self):\n if self.results is not None:\n return tuple(self.results['drug'].unique())",
"def _get_unique_genres(connection):\n print('---Getting unique genres---')\n genreDict = {}\n cursor = connection.cursor()\n cursor.execute(\"SELECT * FROM shared_genres;\")\n ... | [
"0.6729187",
"0.5912013",
"0.57591486",
"0.5738331",
"0.5666848",
"0.5649718",
"0.5634769",
"0.562001",
"0.56132656",
"0.5601305",
"0.55995375",
"0.55618244",
"0.55507255",
"0.5541687",
"0.5520323",
"0.5516712",
"0.5491589",
"0.54879695",
"0.54779065",
"0.54644716",
"0.545142... | 0.68579596 | 0 |
Number of unique names for each drug is correcy. | def test_get_num_unique_name(self):
list1 = self.test_num_unique_name
list2 = get_num_unique_name(self.test_sorted_tuple, self.test_dict)
self.assertEqual(list1, list2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(self):\n return len(self.names)",
"def __len__(self):\n return self.data.index.get_level_values(0).to_series().nunique()",
"def number_of_variables(dataset, name_of_variable):\r\n first_row = dataset[0].keys()\r\n num = 0\r\n for variable in first_row:\r\n if name_of_var... | [
"0.62920433",
"0.60662675",
"0.5955769",
"0.59471035",
"0.5925419",
"0.5915438",
"0.5910354",
"0.58735096",
"0.586835",
"0.58442324",
"0.58086777",
"0.57781553",
"0.5766293",
"0.5765629",
"0.5764152",
"0.57473814",
"0.5723728",
"0.5690694",
"0.56676644",
"0.56587267",
"0.5648... | 0.0 | -1 |
Total cost of each drug is correct. | def test_get_total_cost_each_drug(self):
list1 = self.test_total_cost_each_drug
list2 = get_total_cost_each_drug(self.test_sorted_tuple, self.test_dict)
self.assertEqual(list1, list2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cost(self) -> float:",
"def tablecost(self):\n subtotal_getter = operator.attrgetter(\"subtotal\")\n\n cost = 0.0\n\n cost += sum(map(subtotal_getter, self.materials))\n cost += sum(map(subtotal_getter, self.processes))\n cost += sum(map(subtotal_getter, self.fasteners))\n ... | [
"0.7039642",
"0.68268335",
"0.6784941",
"0.67635846",
"0.6760325",
"0.66375047",
"0.66135275",
"0.65899247",
"0.65713847",
"0.6541224",
"0.6456955",
"0.6456513",
"0.6444531",
"0.6374481",
"0.6351378",
"0.63261276",
"0.6230316",
"0.6212625",
"0.6205208",
"0.6195797",
"0.618874... | 0.68602717 | 1 |
The output file is as expected. | def test_print_drug_info(self):
pwd = self.get_script_path()
fout1 = self.test_output_file
fout2 = pwd+'/../insight_testsuite/tests/my_test/output/test_output_file_2.txt'
print_drug_info(self.test_sorted_tuple, self.test_dict, self.test_num_unique_name, self.test_total_cost_each_drug, f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_output(self):",
"def write_actual_output(self, output):\n actual_output_file = path.splitext(self.source_name)[0] + \".actual\"\n with open(actual_output_file, \"w\") as f:\n f.write(output)",
"def _toFile(self):\n pass",
"def test_outfile():\n\n out_file = random... | [
"0.68608725",
"0.68279564",
"0.67969465",
"0.67020315",
"0.65961033",
"0.6551729",
"0.65434563",
"0.65230155",
"0.6469242",
"0.6408502",
"0.63981223",
"0.63253784",
"0.6316267",
"0.6316267",
"0.63015395",
"0.6297902",
"0.6295766",
"0.62910724",
"0.62809604",
"0.6252292",
"0.6... | 0.0 | -1 |
check if a user exist in the db | def __check_user_exist(self):
login_form = self.login_form()
user = User.query.filter_by(username=login_form.username.data).first()
if user is None or not user.get_password(login_form.password.data):
flash('Invalid username or password') # TODO: flash in Template hinzufuegen
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def userExists(self, username):\n data = db.session.query(User.id).filter_by(username = username).first()\n if data is None:\n return False\n else:\n return True",
"def exists_in_db(self) -> bool:\n query = \"\"\"SELECT * \n FROM Users \n ... | [
"0.8210985",
"0.8123747",
"0.8072711",
"0.8056698",
"0.80316305",
"0.7948778",
"0.79255694",
"0.78522176",
"0.7824358",
"0.7791029",
"0.7768088",
"0.7739863",
"0.7722479",
"0.77069974",
"0.77069974",
"0.7654071",
"0.76501435",
"0.7623449",
"0.76128906",
"0.76000804",
"0.75982... | 0.7002597 | 79 |
Checks if a string is a permutation of a palindrome by populating a map and counting the occurrences of letters. O(N) | def is_palindrome_permutation(string):
letter_to_count = dict()
for letter in string:
letter_to_count[letter] = letter_to_count.get(letter, 0) + 1
residual = 0
for count in letter_to_count.values():
residual += count % 2
# there are can be a single letter with an odd character co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def palindrom_permutation(string: str):\n string = re.sub(r'\\W+', '', string.lower())\n\n chars = dict()\n for c in string:\n chars[c] = chars[c] + 1 if c in chars else 1\n\n almost_not_okey = False\n for val in chars.values():\n if val % 2 == 1:\n if not almost_not_okey:\n... | [
"0.79791397",
"0.7845905",
"0.7619931",
"0.7566796",
"0.72823507",
"0.7219113",
"0.72079515",
"0.71518576",
"0.7108441",
"0.6992611",
"0.69697845",
"0.6915593",
"0.6882766",
"0.6821809",
"0.6709572",
"0.6699704",
"0.65028495",
"0.6462751",
"0.645578",
"0.64369947",
"0.6321017... | 0.81786555 | 0 |
Add ops for dataset loaders to graph | def generate_dataset(self):
if self.training:
dataset = UnpairedDataset(self.opt, self.training)
datasetA, datasetB = dataset.generate(cacheA='./dataA.tfcache', cacheB='./dataB.tfcache')
dataA_iter = datasetA.make_initializable_iterator()
dataB_iter = datasetB.mak... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def import_ops(self):\n if self.is_training:\n self.lr = tf.get_collection_ref(\"lr\")[0]\n self.new_lr = tf.get_collection_ref(\"new_lr\")[0]\n self.lr_update = tf.get_collection_ref(\"lr_update\")[0]\n\n self.cost = tf.get_collection_ref(util.with_prefix(self.name, \"cost\... | [
"0.65246606",
"0.6266942",
"0.59693766",
"0.59283423",
"0.5864471",
"0.57984567",
"0.57888275",
"0.57675457",
"0.5730815",
"0.56816316",
"0.56744856",
"0.5652499",
"0.5620212",
"0.55867034",
"0.5557611",
"0.55549645",
"0.54842335",
"0.5481167",
"0.5478355",
"0.54730076",
"0.5... | 0.0 | -1 |
Build TensorFlow graph for MaskShadowGAN model. | def build(self):
# add ops for generator (A->B) to graph
self.G = Generator(channels=self.opt.channels, ngf=self.opt.ngf, norm_type=self.opt.layer_norm_type,
init_type=self.opt.weight_init_type, init_gain=self.opt.weight_init_gain,
training=self.trai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_graph(self, inputs, masks):\n with vs.variable_scope(\"SimpleSoftmaxLayer\"):\n\n # Linear downprojection layer\n logits = tf.contrib.layers.fully_connected(inputs, num_outputs=1, activation_fn=None) # shape (batch_size, seq_len, 1)\n logits = tf.squeeze(logits, ax... | [
"0.69234383",
"0.69234383",
"0.6907245",
"0.6791445",
"0.6789565",
"0.6765206",
"0.6709734",
"0.66579914",
"0.6548826",
"0.65472156",
"0.6503266",
"0.6484194",
"0.6441474",
"0.6392635",
"0.6377581",
"0.6376619",
"0.6360305",
"0.63222873",
"0.6321313",
"0.63196373",
"0.6286161... | 0.6129226 | 37 |
Compute the losses for the generators and discriminators. | def __loss(self, fakeA, fakeB, reconstructedA, reconstructedB, identA, identB):
# compute the generators loss
G_loss = self.__G_loss(self.D_B, fakeB)
F_loss = self.__G_loss(self.D_A, fakeA)
cc_loss = self.__cycle_consistency_loss(reconstructedA, reconstructedB)
ident_loss = self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_losses(self):\n cycle_consistency_loss_a = \\\n self._lambda_a * losses.cycle_consistency_loss(\n real_images=self.input_a, generated_images=self.cycle_images_a,\n )\n cycle_consistency_loss_b = \\\n self._lambda_b * losses.cycle_consistency... | [
"0.7707404",
"0.7442763",
"0.69570446",
"0.69570446",
"0.6913104",
"0.6866929",
"0.6692329",
"0.6500259",
"0.64484847",
"0.6443854",
"0.6421832",
"0.64056575",
"0.63885695",
"0.6378459",
"0.6364855",
"0.6319561",
"0.62842685",
"0.6246546",
"0.624369",
"0.6235395",
"0.62323135... | 0.6739313 | 6 |
Compute the discriminator loss. | def __D_loss(self, D, real, fake):
loss = 0.5 * (tf.reduce_mean(tf.squared_difference(D(real), 1.0)) + \
tf.reduce_mean(tf.square(D(fake))))
return loss | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _define_discriminator_loss(self):\n real_d_loss = tf.reduce_mean(self._real_discriminator_out)\n real_d_loss = tf.negative(real_d_loss, name='real_discriminator_loss')\n gen_d_loss = tf.reduce_mean(self._gen_discriminator_out,\n name='gen_discriminator_loss')\n return... | [
"0.8110355",
"0.78501636",
"0.7769317",
"0.7654356",
"0.7549625",
"0.7488209",
"0.73963207",
"0.7360349",
"0.7320101",
"0.7283635",
"0.72751373",
"0.7269417",
"0.7124739",
"0.7010574",
"0.699223",
"0.69803566",
"0.69646436",
"0.69372475",
"0.6897706",
"0.6882033",
"0.684818",... | 0.65725476 | 36 |
Compute the generator loss. | def __G_loss(self, D, fake):
loss = tf.reduce_mean(tf.squared_difference(D(fake), 1.0))
return loss | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generator_loss(self, disc_generated_output, gen_output, target):\n # Compute the loss function\n loss_function = self.loss_func()\n\n # Generated GAN loss\n gan_loss = loss_function(tf.ones_like(disc_generated_output), disc_generated_output)\n\n # L1 loss\n l1_loss = t... | [
"0.77820057",
"0.7764371",
"0.75634307",
"0.75527585",
"0.74715674",
"0.73343015",
"0.73278564",
"0.7294605",
"0.7289977",
"0.72849333",
"0.7278991",
"0.7254628",
"0.72545844",
"0.72445464",
"0.7168463",
"0.71656865",
"0.71556157",
"0.71551716",
"0.7152865",
"0.71504474",
"0.... | 0.67413956 | 52 |
Compute the cycle consistenty loss. L_cyc = lamA [Expectation of L1_norm(F(G(A)) A)] + lamb [Expectation of L1_norm(G(F(B)) B)] | def __cycle_consistency_loss(self, reconstructedA, reconstructedB):
loss = self.opt.lamA * tf.reduce_mean(tf.abs(reconstructedA - self.realA)) + \
self.opt.lamB * tf.reduce_mean(tf.abs(reconstructedB - self.realB))
return loss | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cycle_consistency_loss(self, ra, rb, fa, fb):\n with tf.device(\"/gpu:0\"):\n backward_loss = tf.reduce_mean(tf.abs(self.Ga2b(fa) - rb))\n with tf.device(\"/gpu:1\"):\n forward_loss = tf.reduce_mean(tf.abs(self.Gb2a(fb) - ra))\n loss = self.lambda1 * forward_loss ... | [
"0.661372",
"0.61719704",
"0.60370505",
"0.5863777",
"0.569097",
"0.5663334",
"0.56262916",
"0.5592393",
"0.54651314",
"0.5444343",
"0.53959835",
"0.5394466",
"0.53734285",
"0.53725505",
"0.5371813",
"0.5362057",
"0.5342894",
"0.53264534",
"0.5277725",
"0.5275031",
"0.5255691... | 0.6959504 | 0 |
Compute the identity loss. L_idt = lamda_idt [lamA [Expectation of L1_norm(F(A) A)] + lamB [Expectation of L1_norm(G(B) B)]] | def __identity_loss(self, identA, identB):
loss = self.opt.lambda_ident * (self.opt.lamA * tf.reduce_mean(tf.abs(identB - self.realA)) + \
self.opt.lamB * tf.reduce_mean(tf.abs(identA - self.realB)))
return loss | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l1_loss(inputs, reduction='mean', **kwargs):\n args = ArgHelper.parse(locals())\n args['reduction'] = reduction.upper()\n op_lib = loss_ops_lib.L1Loss\n if context.executing_eagerly():\n return op_lib \\\n .instantiate(reduction=args['reduction']) \\\n .apply(inputs)\n ... | [
"0.5652646",
"0.5454709",
"0.5431929",
"0.5346413",
"0.52700704",
"0.5245193",
"0.5241548",
"0.5189512",
"0.51814455",
"0.51782507",
"0.51747054",
"0.5168681",
"0.5149222",
"0.51125103",
"0.510106",
"0.50966114",
"0.5086483",
"0.50756854",
"0.50619715",
"0.5041158",
"0.502635... | 0.69998527 | 0 |
Modified optimizer taken from vanhuyz TensorFlow implementation of CycleGAN | def __optimizers(self, Gen_loss, D_A_loss, D_B_loss):
def make_optimizer(loss, variables, name='Adam'):
""" Adam optimizer with learning rate 0.0002 for the first 100k steps (~100 epochs)
and a linearly decaying rate that goes to zero over the next 100k steps
"""
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, sess, max_iter=50001, optim='adagrad', learning_rate=1e-2,\n d_per_iter=1, g_per_iter=2, d_update=True, g_update=True,\n real_n=1000, real_dim=2, fake_n=1000, z_dim=3, g_out_dim=2,\n g_layers_depth=5, g_layers_width=None, g_activations=None,\n d_out_di... | [
"0.6959912",
"0.6959529",
"0.6903491",
"0.68603384",
"0.6580812",
"0.6557089",
"0.65515715",
"0.6538013",
"0.64774996",
"0.64496166",
"0.6435693",
"0.6410382",
"0.63923454",
"0.6380889",
"0.63773113",
"0.6373982",
"0.6361317",
"0.63536835",
"0.6332485",
"0.631817",
"0.6312744... | 0.626492 | 22 |
Adam optimizer with learning rate 0.0002 for the first 100k steps (~100 epochs) and a linearly decaying rate that goes to zero over the next 100k steps | def make_optimizer(loss, variables, name='Adam'):
global_step = tf.Variable(0, trainable=False, name='global_step')
starter_learning_rate = self.opt.lr
end_learning_rate = 0.0
start_decay_step = self.opt.niter
decay_steps = self.opt.niter_decay
bet... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def adam_optimizer(loss, initial_lr, decay_step, decay_rate):\n global_step = tf.train.get_or_create_global_step()\n lr = tf.train.exponential_decay(initial_lr, global_step, decay_step,\n decay_rate, staircase=True)\n\n optim = tf.train.AdamOptimizer(learning_rate=lr)\n ... | [
"0.7543031",
"0.73133004",
"0.724946",
"0.7170338",
"0.7165979",
"0.7088052",
"0.7046958",
"0.6981401",
"0.6972685",
"0.69598085",
"0.6947667",
"0.69352144",
"0.69040656",
"0.6877185",
"0.68620074",
"0.6840973",
"0.68289465",
"0.6801931",
"0.67928517",
"0.6781422",
"0.6772846... | 0.68411076 | 15 |
Insert object into the Property Sheet to display it. Object must implements the GetPropList interface. This interface returns the dictionary with keys as the groups labels and values as dictionary with keys as property labels and values as property value objects | def SetPropObject(self, obj):
if self.propObj is not None:
# deregister notification
if hasattr(self.propObj, "DropPropsNotify") :
self.propObj.DropPropsNotify()
if hasattr(obj, "GetPropList") :
self.propObj = obj
self.UpdateGrid()
else :
wx.MessageBox(_("Can't display properties for %s, becaus... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def define_group_properties(self):\n\n # PropertyGroup\n self.propertygroup['debug']['x86'] = get_propertygroup(\n 'debug', 'x86', ' and @Label=\"Configuration\"'\n )\n self.propertygroup['debug']['x64'] = get_propertygroup(\n 'debug', 'x64', ' and @Label=\"Configu... | [
"0.5784708",
"0.5752772",
"0.5563086",
"0.55042255",
"0.54970247",
"0.54590595",
"0.5275027",
"0.52564776",
"0.51849294",
"0.51720124",
"0.50716716",
"0.5064659",
"0.5059839",
"0.5025119",
"0.50181776",
"0.4982828",
"0.49804395",
"0.4961031",
"0.49296808",
"0.49119613",
"0.49... | 0.50260586 | 13 |
Parses a tensorflow.SequenceExample into an image and caption. | def parse_sequence_example(serialized, image_id, image_feature, caption_feature):
context, sequence = tf.parse_single_sequence_example(
serialized,
context_features={
image_id : tf.FixedLenFeature([], dtype=tf.int64),
image_feature: tf.FixedLenFeature([], dtype=tf.string)
}... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_sequence_example(serialized, image_feature, caption_feature):\n\tcontext, sequence = tf.parse_single_sequence_example(\n\t\t\tserialized,\n\t\t\tcontext_features={\n\t\t\t\t\timage_feature: tf.FixedLenFeature([], dtype=tf.string)\n\t\t\t},\n\t\t\tsequence_features={\n\t\t\t\t\tcaption_feature: tf.FixedLe... | [
"0.7773432",
"0.70653176",
"0.6706283",
"0.66781205",
"0.66210777",
"0.6502138",
"0.63294804",
"0.63211375",
"0.62616134",
"0.62233996",
"0.6201436",
"0.6195922",
"0.6186161",
"0.6184599",
"0.6164636",
"0.6148699",
"0.6147658",
"0.614749",
"0.6147216",
"0.61331445",
"0.609978... | 0.7657589 | 1 |
Decodes and processes an image string. | def process_image(encoded_image, config, thread_id=0):
return image_processing.process_image(encoded_image,
is_training=False,
height=config.image_height,
width=config.image_width,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_image_string(self, image_string):\n image = image_util.load_image_from_string(image_string)\n return self.process_image(image)",
"def convert_str_to_image(image_string):\n image = image_string.partition('base64,')[2]\n img_data = base64.b64decode(image)\n return img_data",
"d... | [
"0.76571083",
"0.70518196",
"0.67220795",
"0.6707585",
"0.66721165",
"0.6323393",
"0.6302396",
"0.6182582",
"0.61463886",
"0.6065278",
"0.6065278",
"0.603599",
"0.6005533",
"0.5996547",
"0.59715015",
"0.5929471",
"0.5828417",
"0.58076036",
"0.5807062",
"0.57541275",
"0.573893... | 0.52232766 | 74 |
Estimate ND similarity transformation with or without scaling. | def umeyama(src, dst, estimate_scale):
num = src.size(0)
dim = src.size(1)
# Compute mean of src and dst.
src_mean = src.mean(dim=0) # [N]
dst_mean = dst.mean(dim=0) # [N]
# Subtract mean from src and dst.
src_demean = src - src_mean # [M, N]
dst_demean = dst - dst_mean # [M, N]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calculate_trilinear_similarity(self, context, query, context_max_len, query_max_len,\n w4mlu, bias):\n\n subres0 = nd.tile(self.w4c(context), [1, 1, query_max_len])\n subres1 = nd.tile(nd.transpose(\n self.w4q(query), axes=(0, 2, 1)), [1, context... | [
"0.5920537",
"0.5897834",
"0.5621034",
"0.55399406",
"0.5531732",
"0.54380125",
"0.54253316",
"0.539818",
"0.5361793",
"0.53471076",
"0.53471076",
"0.5319093",
"0.5299263",
"0.529202",
"0.52626157",
"0.52620703",
"0.52577376",
"0.52334017",
"0.5212186",
"0.52016556",
"0.51950... | 0.5116158 | 31 |
Run demo, testing whether input words are beer related. | def run_demo():
while True:
embeddings = beer_emb.embed_doc(input("Test if words are beer-related: "),
word_filter=False)
for word_vec in embeddings:
print(is_beer_related(word_vec)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_run():\r\n print(count_words(\"cat bat mat cat bat cat\", 3))\r\n print(count_words(\"betty bought a bit of butter but the butter was bitter\", 3))",
"def test_run():\n print count_words(\"cat bat mat cat bat cat\", 3)\n print count_words(\"betty bought a bit of butter but the butter was bit... | [
"0.64361274",
"0.63639456",
"0.63639456",
"0.61933094",
"0.5985079",
"0.59168476",
"0.58774954",
"0.58620715",
"0.58588994",
"0.5743201",
"0.57326597",
"0.57213676",
"0.5714051",
"0.57126486",
"0.5685293",
"0.56775856",
"0.56722903",
"0.56616175",
"0.56303006",
"0.5619225",
"... | 0.7582199 | 0 |
Creates and saves a new user | def create_user(self, phone, password=None, **extra_fields):
print(extra_fields)
if not phone:
raise ValueError('Users must have an phone number')
if not password:
raise ValueError('Users must have a password')
try:
extra_fields['role']
except ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_user():\n record = request.get_json()\n if record is None:\n return {\"Error\": \"No data Supplied.\"}, 400\n\n schema = user_schema.load(record)\n\n if UserModel.objects(email=schema['email']):\n return {\"Error\": \"User Data already exists.\"}, 400\n user = UserModel(**s... | [
"0.81209964",
"0.7988362",
"0.7942134",
"0.794042",
"0.7909767",
"0.79059476",
"0.7895585",
"0.78710216",
"0.7859143",
"0.7820724",
"0.78207135",
"0.7810844",
"0.77932024",
"0.77833587",
"0.77703035",
"0.77604187",
"0.7755999",
"0.77458596",
"0.7740836",
"0.773325",
"0.771976... | 0.0 | -1 |
Creates and saves a new super user | def create_superuser(self, phone, password):
user = self.model(phone=phone)
user.set_password(password)
user.save(using=self._db)
user.is_staff = True
user.is_superuser = True
user.save(using=self._db)
return user | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_superuser(self, username, email, password):\n print(\"creating super user....\")\n user = self.create_user(\n\n username=username,\n password=password,\n email = email,\n commit=False,\n )\n user.is_staff = True\n user.is_sup... | [
"0.770437",
"0.76964134",
"0.76661605",
"0.76653856",
"0.7655734",
"0.75484675",
"0.7541768",
"0.75341594",
"0.75114566",
"0.7500617",
"0.74416953",
"0.74323356",
"0.7431842",
"0.74239194",
"0.7409911",
"0.73949206",
"0.73942757",
"0.73923373",
"0.7387035",
"0.7382646",
"0.73... | 0.0 | -1 |
return least common multiple of two integers | def lcm(x: int, y: int) -> int:
assert isinstance(x, int) and isinstance(y, int) and x > 0 and y > 0
return int(x * y / gcd(x, y)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def least_common_multiple(number1, number2):\n return number1 * number2 // math.gcd(number1, number2)",
"def lowest_common_multiple(a, b):\n # 两个数字相乘后除以最大公约数 = 两个数字的最小公倍数\n return a * b // gcd(a, b)",
"def least_common_multiple2(number1, number2, number3, number4):\n return least_common_multiple((n... | [
"0.8421955",
"0.8331325",
"0.7644219",
"0.76081353",
"0.75759864",
"0.75759864",
"0.75638235",
"0.7436232",
"0.73484886",
"0.7300214",
"0.7295642",
"0.72913396",
"0.72913396",
"0.72913396",
"0.72913396",
"0.72913396",
"0.72913396",
"0.72913396",
"0.72913396",
"0.72913396",
"0... | 0.71541774 | 27 |
return the greatest common divisor of two integers | def gcd(x: int, y: int) -> int:
assert isinstance(x, int) and isinstance(y, int) and x > 0 and y > 0
while y != 0:
x, y = y, x % y
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def greatest_common_divisor(x: int, y: int) -> int:\n while y != 0:\n (x, y) = (y, x % y)\n return x",
"def greatest_common_divisor(a: int, b: int) -> int:\n#[SOLUTION]\n while b:\n a, b = b, a % b\n return a",
"def gcd_algo(a,b):\n i = max(a,b)\n j = min(a,b)\n\n if j == 0:\... | [
"0.85697377",
"0.8548809",
"0.80010635",
"0.7985648",
"0.7972896",
"0.7921842",
"0.78888613",
"0.7888709",
"0.78645015",
"0.78455526",
"0.7827044",
"0.7827044",
"0.7821854",
"0.7792171",
"0.7777419",
"0.7754992",
"0.775436",
"0.775147",
"0.77433187",
"0.77408284",
"0.77301985... | 0.75848126 | 49 |
return least common multiple of a range of integers | def lcms(argg: range) -> int:
l = 1
for arg in argg:
l = lcm(l, arg)
return l | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def smallest_multiple(n):\n return reduce(lowest_common_multiple, range(1, n+1))",
"def least_common_multiple(number1, number2):\n return number1 * number2 // math.gcd(number1, number2)",
"def lowest_common_multiple(a, b):\n # 两个数字相乘后除以最大公约数 = 两个数字的最小公倍数\n return a * b // gcd(a, b)",
"def find_sm... | [
"0.7665987",
"0.75820744",
"0.7434193",
"0.725471",
"0.71709675",
"0.6794163",
"0.6781177",
"0.6689504",
"0.6673474",
"0.66556793",
"0.66154504",
"0.6614286",
"0.66003877",
"0.65978855",
"0.65978855",
"0.65896875",
"0.6571934",
"0.65678567",
"0.6525186",
"0.65232986",
"0.6469... | 0.6465514 | 21 |
Creates a UNet model with pretrained optiopn. | def unet(num_classes=21, is_deconv=False, feature_scale=1, is_batchnorm=True, pretrained=False):
if pretrained:
model_path = pretrained_models['pascal']
model = UNet(n_classes=num_classes, feature_scale=feature_scale, is_batchnorm=is_batchnorm, is_deconv=is_deconv)
checkpoint = torch.load(mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_unet_model(self):\n # create optimizer instance\n config = {\n 'class_name': self.optimizer,\n 'config': self.optimizer_params}\n optimizer = get_optimizer(config)\n\n self.model = unet(optimizer=optimizer,\n loss=self.loss,\n ... | [
"0.68969065",
"0.665536",
"0.62934476",
"0.61874026",
"0.6184248",
"0.6179625",
"0.6171186",
"0.6165023",
"0.61580503",
"0.6156004",
"0.61520237",
"0.6149518",
"0.6119684",
"0.61149585",
"0.60775506",
"0.6073373",
"0.60634506",
"0.605574",
"0.60486454",
"0.6038523",
"0.601402... | 0.6460649 | 2 |
Download text from the given url to fname. | def download_target_url(target, fname):
r = requests.get(target)
if r.ok:
with open(fname, 'w') as f:
f.write(r.text)
print(f"Wrote {len(r.text)} chars to {fname}.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_file(url, fname):\n urllib.request.urlretrieve(url, fname)",
"def download (url):\n path, url = url\n r = requests.get (url, stream = True)\n content = r.text\n #print (content)\n with open (path + '.txt', 'w') as f:\n f.write (content)",
"def download_link(url,save_dir):\... | [
"0.7638134",
"0.755848",
"0.73113656",
"0.72749597",
"0.7246588",
"0.7025229",
"0.70069635",
"0.6974052",
"0.6928931",
"0.6926085",
"0.69255304",
"0.6919365",
"0.6906989",
"0.6897153",
"0.68755436",
"0.68460965",
"0.683638",
"0.68292296",
"0.6827624",
"0.6824476",
"0.6773361"... | 0.705656 | 5 |
Load parsed beautifulsoup object holding the full html | def load_parsed(self):
with open(self.fname) as f:
self.parsed = BeautifulSoup(f.read(), features="html.parser") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_website(self):\n# r = urllib.request.urlopen(self.url).read()\n r = requests.get(self.url).content \n self.soup = bs(r, \"lxml\")",
"def load_page(self) -> bs4.BeautifulSoup:\n\n res = requests.get(self.url)\n\n res.raise_for_status()\n return bs4.Beautif... | [
"0.7414255",
"0.7408412",
"0.7246797",
"0.7061659",
"0.6892907",
"0.68442833",
"0.6834316",
"0.6795834",
"0.6783969",
"0.67211264",
"0.67171395",
"0.6716718",
"0.66845864",
"0.6660223",
"0.660617",
"0.65939754",
"0.6587271",
"0.6559653",
"0.65470797",
"0.6519594",
"0.65095526... | 0.7917264 | 0 |
Iterator over maintext paragraph elements; this includes footnotes. | def _paragraphs_raw(self):
for par in self.parsed.find_all("p")[self.PAR_START:]:
yield par | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def linked_text_paragraphs(self):\n for par in self._main_paragraphs_raw():\n par_links = par.find_all('a')\n if len(par_links) == 0:\n self.main_count += len(par.text)\n yield par.text\n else:\n for el in par.contents:\n ... | [
"0.70568925",
"0.6538393",
"0.630119",
"0.6105424",
"0.59029144",
"0.5857844",
"0.56422466",
"0.561061",
"0.5597017",
"0.5584193",
"0.55805284",
"0.55002755",
"0.5490439",
"0.5486235",
"0.5449823",
"0.5444187",
"0.5435644",
"0.5427534",
"0.5414275",
"0.54038227",
"0.5385818",... | 0.6565161 | 1 |
Checks whether an element contains footnote text. | def is_footnote_text(self, par):
return (par is not None) and ("foot" in par.attrs.get("class", [])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_footnote(self, par):\n if par.find_next_sibling('p') is None:\n return False\n return self.is_footnote_text(par) or self.is_footnote_link(par)",
"def is_footnote_link(self, par):\n return self.is_footnote_text(par.find_next_sibling('p'))",
"def is_footnote(self):\n ... | [
"0.72341335",
"0.688278",
"0.6498541",
"0.6382326",
"0.61090255",
"0.6085547",
"0.59022486",
"0.5810465",
"0.5732255",
"0.5724639",
"0.56633186",
"0.55054045",
"0.54965115",
"0.5481354",
"0.54613525",
"0.5442589",
"0.5437752",
"0.54305816",
"0.53904307",
"0.5370518",
"0.53681... | 0.80490977 | 0 |
Checks whether an element is a link adjacent to footnote text. | def is_footnote_link(self, par):
return self.is_footnote_text(par.find_next_sibling('p')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_footnote(self, par):\n if par.find_next_sibling('p') is None:\n return False\n return self.is_footnote_text(par) or self.is_footnote_link(par)",
"def is_link(s):\n return (len(s) == 2 and is_link(s[1])) or s == empty",
"def check_link(self, link, links_para):\n href =... | [
"0.69997984",
"0.6757967",
"0.6695195",
"0.66264176",
"0.66264176",
"0.66264176",
"0.63451207",
"0.6296661",
"0.6101461",
"0.60751194",
"0.604954",
"0.6045755",
"0.60173523",
"0.5861832",
"0.5820362",
"0.5799617",
"0.5760772",
"0.57050264",
"0.5704481",
"0.5701879",
"0.569843... | 0.8036169 | 0 |
Checks whether a paragraph element is part of a footnote. | def is_footnote(self, par):
if par.find_next_sibling('p') is None:
return False
return self.is_footnote_text(par) or self.is_footnote_link(par) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_footnote_text(self, par):\n return (par is not None) and (\"foot\" in par.attrs.get(\"class\", []))",
"def is_footnote_link(self, par):\n return self.is_footnote_text(par.find_next_sibling('p'))",
"def is_footnote(self):\n return self.style['float'] == 'footnote'",
"def check_mark... | [
"0.8045934",
"0.7436927",
"0.6865161",
"0.60696536",
"0.60482085",
"0.6026402",
"0.6006918",
"0.57114613",
"0.56973517",
"0.56481415",
"0.5624542",
"0.55489916",
"0.5463017",
"0.53871185",
"0.52857167",
"0.5267883",
"0.5256443",
"0.5246128",
"0.5203835",
"0.5170078",
"0.51535... | 0.79070187 | 1 |
Checks whether a paragraph is part of a table of contents. | def is_toc(self, par):
return "toc" in par.attrs.get("class", []) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isTable(line):\n # Make the string easier to parse.\n line_stripped = lineNormalise(line)\n\n # Return value.\n ret = False\n\n # If the line starts with the word table, we have a table definition!\n if line_stripped.startswith('table'):\n ret = True\n\n # Tell the horrible truth th... | [
"0.64335525",
"0.6316292",
"0.5921447",
"0.5887786",
"0.5816467",
"0.58017445",
"0.5749812",
"0.5692028",
"0.56918216",
"0.56839854",
"0.56645924",
"0.5649797",
"0.5557572",
"0.5544824",
"0.5544294",
"0.553953",
"0.5523673",
"0.5453183",
"0.54286253",
"0.5415694",
"0.53847057... | 0.6113981 | 2 |
Returns paragraph element corresponding to the given id. | def _get_footnote_par(self, id):
start = self._current_body_par
if start is None:
start = self.parsed
link = start.find_next(id=id)
if link is None:
raise NoFootnoteError(f"Could not find id {id}")
foot_par = link.parent.find_next_sibling('p')
if n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getitem__(self, pID: int) -> Tuple[int, str, str]:\n\n try:\n return next(self._cursor.execute(\n f\"SELECT id, raw_document_title, raw_paragraph_context FROM paragraphs WHERE id = ?\", (pID,)\n ))\n except StopIteration:\n raise KeyError(... | [
"0.62857157",
"0.6051216",
"0.6041252",
"0.5996266",
"0.5886566",
"0.58803475",
"0.581452",
"0.57547826",
"0.5694344",
"0.56772363",
"0.5660466",
"0.5647002",
"0.5594322",
"0.55925494",
"0.55812985",
"0.5573686",
"0.5553297",
"0.5532051",
"0.5492356",
"0.54790217",
"0.5463343... | 0.5871431 | 6 |
Walk over pararaphs in the main text. If a footnote link is found, jump to that paragraph, then back to the main text. | def linked_text_paragraphs(self):
for par in self._main_paragraphs_raw():
par_links = par.find_all('a')
if len(par_links) == 0:
self.main_count += len(par.text)
yield par.text
else:
for el in par.contents:
if... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def segment_paragraphs(root_el, cites=[]):\n from capdb.models import Citation\n\n last_el_ends_mid_sentence = False\n join_with_last_el = False\n html_to_prepend_to_next_el = ''\n\n # build a lookup like {\"935 F.3d\": 1, \"123 Mass.\": 2}\n reporter_indexes = {}\n for i, cite in enumerate(Ci... | [
"0.5886465",
"0.58725065",
"0.58705807",
"0.57472676",
"0.56360775",
"0.55975014",
"0.5573705",
"0.5540514",
"0.54371405",
"0.54029816",
"0.53338504",
"0.53178537",
"0.5315798",
"0.5282773",
"0.52491987",
"0.52362645",
"0.5195637",
"0.5168886",
"0.513893",
"0.51377296",
"0.51... | 0.6464983 | 0 |
Tokenize on linebyline basis. | def tokenize_generic(self, tokenizer, N=None, drop_punctuation=True):
ct, done = 0, False
with open(self.textfile) as f:
for ln in f.readlines():
if done:
break
ln = ln.replace("(return)", "")
for token in tokenizer(ln.strip... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tokenize_words(line):\n return",
"def tokenize(\n self, text_row: Optional[List[str]], token_row: Optional[List[List[str]]]\n ):\n raise NotImplementedError",
"def tokenize_line(line, max_line_length=None, number_token=None, name_token=None, gpe_token=None):\n new_line = word_tokeniz... | [
"0.69884706",
"0.66323274",
"0.6459621",
"0.64471626",
"0.6395952",
"0.6366297",
"0.63627106",
"0.6332375",
"0.62884957",
"0.62397844",
"0.620047",
"0.61909837",
"0.6182466",
"0.61787194",
"0.6176044",
"0.61732286",
"0.6165838",
"0.6162342",
"0.6160397",
"0.6157418",
"0.61514... | 0.0 | -1 |
tokenize using the nltk default (ptb + a 'punkt' sentence tokenizer) | def tokenize(self, N=None, drop_punctuation=True, lower=True):
for tok in self.tokenize_generic(word_tokenize, N=N, drop_punctuation=drop_punctuation):
if lower:
tok = tok.lower()
yield tok | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gpt2_tokenize(self, text: str):\n return self.bpe_tokenize(text)",
"def preprocess(text):\n\tX = []\n\tsent_detector = nltk.data.load('tokenizers/punkt/english.pickle')\n\tfor t in text:\n\t\tsents = sent_detector.tokenize(t)\n\t\tresult = ''\n\t\tfor s in sents:\n\t\t\ttokens = word_tokenize(s)\n\t\t... | [
"0.7247982",
"0.7229188",
"0.7094783",
"0.70895004",
"0.70805717",
"0.69946355",
"0.6974862",
"0.6922694",
"0.6919841",
"0.68694",
"0.6835729",
"0.6791642",
"0.67796576",
"0.6747571",
"0.6684571",
"0.66801494",
"0.6662924",
"0.6644727",
"0.66325396",
"0.6598598",
"0.6588903",... | 0.0 | -1 |
boolean of if changes have been made to present sha | def dirty(cls):
output = subprocess.check_output(DIRTY_INCANTATION)
return len(output.strip()) == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_changes(self):\n if self.repo_is_empty:\n return True\n\n tree = self.repo.get(self.index.write_tree(self.repo))\n diff = tree.diff_to_tree(self.repo.get(self.repo.head.target).tree)\n return bool(diff)",
"def index_is_dirty():\n result, output = popen('git diff ... | [
"0.69775397",
"0.6945446",
"0.6825735",
"0.68252903",
"0.6719734",
"0.6671272",
"0.6610195",
"0.6565223",
"0.6532837",
"0.6526835",
"0.6508548",
"0.6499044",
"0.6385325",
"0.63748574",
"0.6319224",
"0.6314689",
"0.63038826",
"0.6292349",
"0.6275215",
"0.6274554",
"0.6246274",... | 0.66552734 | 6 |
Read input from a text file | def read_input():
orbitDict = {}
with open('day06_input.txt') as f:
for line in f:
planet, satellite = line.split(')')
satellite = satellite.rstrip('\n')
if satellite in orbitDict:
orbitDict[satellite].append(planet)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_input():\n return Path(__file__).with_name('input.txt').read_text().splitlines()",
"def read_txt(cls, input_file):\n return open(input_file, \"r\", encoding=\"utf-8\").readlines()",
"def read_txt(cls, input_file):\n return open(input_file, \"r\", encoding=\"utf-8\").readlines()",
"d... | [
"0.80333656",
"0.73937935",
"0.73937935",
"0.7325028",
"0.7260986",
"0.72499967",
"0.72369945",
"0.712606",
"0.7094524",
"0.70686525",
"0.69390434",
"0.6938965",
"0.6922924",
"0.68762004",
"0.68759114",
"0.68530405",
"0.68422097",
"0.67936075",
"0.67765266",
"0.6772103",
"0.6... | 0.0 | -1 |
Counts the number of orbitating planets | def num_of_orbits(orbitDict):
total_orbits = len(orbitDict.keys())
total_orbits += independent_orbits(orbitDict)
return total_orbits | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def orbit_count(self) -> int:\n if self.orbit:\n return 1 + self.orbit.orbit_count()\n return 0",
"def orbit_count(objects: Dict[str, ObjectMass]) -> int:\n total = 0\n\n for mass in objects.values():\n total += mass.orbit_count()\n\n return total",
"def count():",
"d... | [
"0.7507539",
"0.72100306",
"0.617972",
"0.6152469",
"0.61030316",
"0.603404",
"0.6009309",
"0.5947875",
"0.59461266",
"0.5906092",
"0.5883676",
"0.5869086",
"0.58329415",
"0.5806103",
"0.5806103",
"0.5806103",
"0.5806103",
"0.577206",
"0.574075",
"0.57232994",
"0.57174265",
... | 0.6075204 | 5 |
This function identify on which orbits it is possible to meet santa with the least number of jumps | def meet_santa(orbitDict):
santa_count, santa_path = does_orbit('SAN', orbitDict)
your_count, your_path = does_orbit('YOU', orbitDict)
santa_planets = set(santa_path)
your_planets = set(your_path)
common = len(santa_planets.intersection(your_planets))
dist = santa_count + your_count - 2*common
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spotlessroomba_first_heuristic(state : SpotlessRoombaState) -> float:\n # TODO a nontrivial admissible heuristic\n return len(state.dirty_locations)",
"def challenge1(self):\n self.parse_input()\n\n # Find strongest nanobot\n strongest = max(self.nanobots, key=lambda n: n.r)\n\n ... | [
"0.6110882",
"0.60308844",
"0.5878015",
"0.5863746",
"0.5748723",
"0.5709508",
"0.56566536",
"0.56528664",
"0.5624614",
"0.5575636",
"0.5567551",
"0.55536634",
"0.5527198",
"0.55191416",
"0.5517331",
"0.5514932",
"0.5513137",
"0.5498134",
"0.5493011",
"0.54866076",
"0.5477608... | 0.5761488 | 4 |
Returns a Pythonnormalized String object from unicode. | def normalize_unicode_data(data):
normalized_data = unicodedata.normalize('NFKD', data).encode('ascii', 'ignore')
return normalized_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self, string):\r\n if isinstance(string, unicode):\r\n u = string\r\n else:\r\n u = unicode(string, self.encoding)\r\n return u",
"def as_unicode(string):\n return same_string_type_as(\"\", string)",
"def _as_unicode(s):\n if isinstance(s, str):\n ... | [
"0.7233125",
"0.71349865",
"0.7019128",
"0.70103765",
"0.6991322",
"0.6916738",
"0.6904967",
"0.68421304",
"0.6790128",
"0.67792904",
"0.671786",
"0.6711641",
"0.67108285",
"0.66316116",
"0.6597703",
"0.6570314",
"0.6567923",
"0.65449303",
"0.6489974",
"0.645341",
"0.64313215... | 0.0 | -1 |
Material saver. Saves material and their properties the JSON file for type building elements. If the Project parent is set, it automatically saves it to the file given in Project.data. Alternatively you can specify a path to a file with Materials. If this file does not exist, a new file is created. | def save_material(material, data_class):
data_class.material_bind["version"] = "0.7"
add_to_json = True
warning_text = ("Material with same name and same properties already "
"exists in JSON, consider this material or revising your "
"properties")
for id, check ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_material(filename, mat):\n out = np.array([mat.wav, mat.eps.real, mat.eps.imag,\n mat.mu.real, mat.mu.imag]).T\n header = \"Wavelength\\teps_real\\teps_imag\\tmu_real\\tmu_imag\"\n miepy.array_io.save(filename, out, header=header)",
"def WriteStructuralMaterialsjson(save_path... | [
"0.57051945",
"0.55286336",
"0.54615587",
"0.53826904",
"0.5350502",
"0.53496337",
"0.5319556",
"0.52859074",
"0.5285472",
"0.52815086",
"0.5229431",
"0.5202984",
"0.5185666",
"0.5141686",
"0.5140259",
"0.513041",
"0.51060146",
"0.5105606",
"0.50921017",
"0.5083165",
"0.50725... | 0.65841603 | 0 |
Create a new Settings, reading from a default location for the given domain (~/Library/Preferences/%s.plist). | def __init__(self, domain='com.markfickett.gors'):
settingsDir = os.path.expanduser(self.__SETTINGS_DIR)
if not os.path.isdir(settingsDir):
os.makedirs(settingsDir)
self.__settingsFileName = os.path.join(settingsDir,
domain + '.plist')
if os.path.isfile(self.__settingsFileName):
self.__settings = plist... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def settings_create(ctx):\n # Choose where and whether to save the configuration file.\n path = ctx.obj['load_path']\n if path:\n click.confirm(\n 'A settings file already exists. Continuing will override it. '\n 'Do you want to continue?',\n abort=True,\n )\... | [
"0.5657144",
"0.548896",
"0.5319334",
"0.5285291",
"0.52768016",
"0.5255273",
"0.5222265",
"0.5218223",
"0.5189833",
"0.5173989",
"0.5170184",
"0.51397663",
"0.513596",
"0.5086622",
"0.50810987",
"0.50810987",
"0.50761354",
"0.5024908",
"0.5006228",
"0.5000491",
"0.5000396",
... | 0.7057614 | 0 |
Create and return a GroupGuard for this Settings object, which prepends a group name to all settings names referenced while it is active. | def groupGuard(self, groupNameRaw):
groupName = str(groupNameRaw)
if self.__DELIMITER in groupName:
raise ValueError(("Illegal group name '%s' contains"
+ " delimiter '%s'.") % (groupName, self.__DELIMITER))
return self._GroupGuard(self, groupName) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_grp(self, name='grp'):\n self.base[name] = self.get_group_array()",
"def createGroup(self):\n return _libsbml.GroupsModelPlugin_createGroup(self)",
"def save_group_and_return_instance(self, groupname=\"\"):\n if groupname == \"\":\n raise ValueError(\"group needs its na... | [
"0.6209012",
"0.5984325",
"0.5788384",
"0.568222",
"0.56628835",
"0.563917",
"0.5622585",
"0.56192756",
"0.56191015",
"0.55996215",
"0.5569049",
"0.5563115",
"0.5557951",
"0.55311483",
"0.550896",
"0.54411197",
"0.54324687",
"0.5423106",
"0.5397997",
"0.53885156",
"0.53813946... | 0.5727455 | 3 |
Return a list of all groups under the current group. (This is potentially slow, as it recomputes every time.) | def getChildGroups(self):
groupPrefix = self.__DELIMITER.join(self.__currentGroupNames)
if groupPrefix:
groupPrefix += self.__DELIMITER
skipLen = len(groupPrefix)
childGroups = set()
for keyName in self.__settings.keys():
if keyName.startswith(groupPrefix):
childKey = keyName[skipLen:]
groupKey,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getGroups(self):\n return [g[0] for g in grp.getgrall()]",
"def list_groups():\n return _list_tindyb_unique_values(\"group\", dbpath=__dbpath__)",
"def get_all_groups(self):\n return self.groups + ['all']",
"def getGroups():\r\n return Group.getGroups()",
"def get_pingroups(self... | [
"0.80298066",
"0.7753639",
"0.7704329",
"0.76670724",
"0.7662189",
"0.7483736",
"0.74683553",
"0.7443777",
"0.7393224",
"0.7341",
"0.7341",
"0.7341",
"0.73013186",
"0.7216928",
"0.7213653",
"0.7186486",
"0.7179003",
"0.7083968",
"0.7080749",
"0.70386165",
"0.7009138",
"0.69... | 0.67759746 | 32 |
Get the full name of the given keyName under the current group. If extant is True, only return extant keys; otherwise return None. | def __getKey(self, keyNameRaw, extant=True):
fullKeyName = self.__DELIMITER.join(
self.__currentGroupNames + [str(keyNameRaw)])
if extant and (fullKeyName not in self.__settings):
return None
return fullKeyName | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def key_name(self) -> Optional[str]:\n return pulumi.get(self, \"key_name\")",
"def get_name(self):\n return self.key().name().split(':', 1)[1]",
"def extract_key_name(self):\n # quick and dirty regex parsing..\n # consider using gnupg.\n _, out, _ = self.as_user('/usr/bin/gp... | [
"0.61867285",
"0.6151179",
"0.59994215",
"0.59087443",
"0.59087443",
"0.58050305",
"0.57887447",
"0.57743907",
"0.57119745",
"0.5711618",
"0.56672543",
"0.5649241",
"0.5592001",
"0.55778885",
"0.55366206",
"0.55205065",
"0.55190045",
"0.55060714",
"0.55060714",
"0.55060714",
... | 0.77827585 | 0 |
This function gets the total occurrences of words and syllables in the original Unicode Garshana corpus. To do this, it opens a .csv file with utf16 encoding, and splits on commans, expecting the line of sumerian text to be in the 8th column. Filters annotations from each line, and tracks the occurrence of each word an... | def get_counts(data):
word_count = {}
syll_count = {}
infile = data.corpus
try:
open_file = codecs.open(infile, 'r', encoding='utf-16')
for line in open_file:
line = line.lower()
# Remove tablet indexing info and line numbers. Grab only text data
li... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_word_counts(filename):\n raw_rows = csv_rows(filename)\n word_counts = defaultdict(lambda: 0)\n\n for line_number, raw_row in enumerate(raw_rows, 2):\n count = int(raw_row[\"count\"])\n ipa = raw_row[\"IPA\"]\n if '*' in ipa:\n continue\n\n # Fixes random badness.. hopefully doesn't hi... | [
"0.6335053",
"0.57268775",
"0.57179636",
"0.5714977",
"0.57052946",
"0.5632471",
"0.56277466",
"0.56243765",
"0.5612738",
"0.5593558",
"0.55885386",
"0.5571546",
"0.5560268",
"0.55578226",
"0.55549335",
"0.55408674",
"0.55253506",
"0.5510573",
"0.55039716",
"0.5502862",
"0.55... | 0.65279776 | 0 |
Update the total occurrence counts of each unigram, bigram, and trigram | def update_syllable_count(word, syll_count):
syllables = word.split('-')
for i in range(1, 4):
for j in range(len(syllables) - i + 1):
gram = '-'.join(syllables[j: j + i])
count = syll_count.setdefault(gram, 0)
syll_count[gram] = count + 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _count(self):\n words = [word.lower() for word in self.corpus.words()]\n bigrams_words = bigrams(words)\n for bigram in bigrams_words:\n self._bigrams[bigram] += 1",
"def count_ngrams(self, corpus):\n \n self.unigramcounts = {} # might want to use defaultdict or Count... | [
"0.7613877",
"0.754076",
"0.7213328",
"0.7121193",
"0.7052331",
"0.6792219",
"0.6738704",
"0.6667053",
"0.6502214",
"0.6489286",
"0.647944",
"0.64368546",
"0.6427307",
"0.641034",
"0.6370047",
"0.6328885",
"0.6313854",
"0.62974036",
"0.62933725",
"0.6273226",
"0.62302506",
... | 0.0 | -1 |
Clean a line of data, removing all annotations from the line. | def clean_line(line, normNum=True, normProf=True):
# Remove square brackets, ceiling characters, question marks, other
# questionable characters, and line breaks
line = re.sub(r'(\[|\])', '', line)
line = re.sub(r'(⌈|⌉)', '', line)
line = re.sub(r'( / )', ' ', line)
line = re.sub(r'/', '', line... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cleaning (data):",
"def clean_line(self, line):\n\n if \"#\" in line:\n temp = line.split(\"#\")\n if len(temp) < 2:\n return \"\"\n else:\n temp = temp[0] + \"\\n\"\n\n # make sure the \"#\" isn't in quotes\n if temp... | [
"0.65842664",
"0.6322053",
"0.61243117",
"0.6106798",
"0.6106798",
"0.6087376",
"0.60553944",
"0.5906017",
"0.5889315",
"0.5888119",
"0.58622",
"0.58618647",
"0.58282447",
"0.58261687",
"0.5818282",
"0.58130705",
"0.57777137",
"0.5760969",
"0.57328576",
"0.57266486",
"0.57165... | 0.6030962 | 7 |
Returns the accounting period that is currently valid. Valid is an accounting_period when the current date lies between begin and end of the accounting_period | def get_current_valid_accounting_period():
current_valid_accounting_period = None
for accounting_period in AccountingPeriod.objects.all():
if accounting_period.begin < date.today() and accounting_period.end > date.today():
return accounting_period
if not current_valid... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCurrentValidAccountingPeriod():\n currentValidAccountingPeriod = None\n for accountingPeriod in AccountingPeriod.objects.all():\n if accountingPeriod.begin < date.today() and accountingPeriod.end > date.today():\n return accountingPeriod\n if currentValidAccoun... | [
"0.82862264",
"0.6872075",
"0.65232825",
"0.6370569",
"0.6290718",
"0.60823673",
"0.6040515",
"0.6040515",
"0.6040515",
"0.6040515",
"0.6040515",
"0.6040515",
"0.6040515",
"0.6040515",
"0.6018042",
"0.6012301",
"0.5940794",
"0.59097856",
"0.5859212",
"0.5821298",
"0.5755713",... | 0.8423247 | 0 |
Returns the accounting period that is currently valid. Valid is an accountingPeriod when the current date lies between begin and end of the accountingPeriod | def get_all_prior_accounting_periods(target_accounting_period):
accounting_periods = []
for accounting_period in AccountingPeriod.objects.all():
if accounting_period.end < target_accounting_period.begin:
accounting_periods.append(accounting_period)
if accounting_perio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_current_valid_accounting_period():\n current_valid_accounting_period = None\n for accounting_period in AccountingPeriod.objects.all():\n if accounting_period.begin < date.today() and accounting_period.end > date.today():\n return accounting_period\n if not cur... | [
"0.84471315",
"0.8381506",
"0.68428826",
"0.6510184",
"0.6339413",
"0.60962486",
"0.60355204",
"0.6016154",
"0.6016154",
"0.6016154",
"0.6016154",
"0.6016154",
"0.6016154",
"0.6016154",
"0.6016154",
"0.6013164",
"0.5948316",
"0.58576053",
"0.58273315",
"0.58267355",
"0.572815... | 0.63429344 | 4 |
Transform mp3 file into wav format calling bash and using mpg123 or ffmpeg. | def mp3_to_wav(mp3_file, wav_file, encoder='mpg123'):
if encoder == 'mpg123':
bash_command = ['mpg123', '-w', wav_file, '--mono', mp3_file]
else:
bash_command = ['ffmpeg', '-i', mp3_file, wav_file]
subprocess.run(bash_command) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mp3_to_wav(show_progress=True):\n\n # Define a devnull var to supress subprocess output\n devnull = open(os.devnull, 'w')\n\n # Get a list of the filepath for each of the mp3 files in each subdirectory of data/fma_small\n file_list = glob.glob('./../data/fma_small/*/*.mp3')\n\n # Get the number ... | [
"0.73525465",
"0.7225452",
"0.7119044",
"0.70570403",
"0.67239785",
"0.6696764",
"0.6579686",
"0.6547333",
"0.6539131",
"0.6505683",
"0.6481485",
"0.64209044",
"0.6362076",
"0.6354701",
"0.632691",
"0.6275299",
"0.62359387",
"0.6216278",
"0.6215746",
"0.61728823",
"0.6155799"... | 0.8660163 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.