def main():
args_parser = argparse.ArgumentParser(
description="Updates 'Chrome Browser Network Traffic Annotations' doc."
)
args_parser.add_argument("--config-file", help="Configurations file.")
args_parser.add_argument(
"--annotations-file",
help="TSV annotations file exported from auditor.")
args_parser.add_argument("--verbose",
action="store_true",
help="Reports all updates. "
" Also creates a scripts/template.json file "
" outlining the document's current structure.")
args_parser.add_argument("--config-help",
action="store_true",
help="Shows the configurations help.")
args = args_parser.parse_args()
if args.config_help:
print_config_help()
return 0
# Load and parse config file.
with open(os.path.join(SRC_DIR, args.config_file)) as config_file:
config = json.load(config_file)
tsv_contents = load_tsv_file(os.path.join(SRC_DIR, args.annotations_file),
False)
if not tsv_contents:
print("Could not read annotations file.")
return -1
xml_parser = XMLParser(
os.path.join(SRC_DIR, "tools/traffic_annotation/summary/grouping.xml"),
map_annotations(tsv_contents))
placeholders = xml_parser.build_placeholders()
print("#" * 40)
print("There are:", len(placeholders), "placeholders")
if args.verbose:
print(placeholders)
print("#" * 40)
network_traffic_doc = NetworkTrafficAnnotationsDoc(
doc_id=config["doc_id"],
doc_name=config["doc_name"],
credentials_file_path=config["credentials_file_path"],
client_token_file_path=config["client_token_file_path"],
verbose=args.verbose)
if not network_traffic_doc.update_doc(placeholders):
return -1
return 0
def runtests(filename):
f = open(filename)
tests = f.read().split("#data\n")
errorAmount = index = 0
errorLog = []
for index, test in enumerate(tests):
if test == "": continue
test = "#data\n" + test
input, expected, errors = parseTestcase(test)
parser = XMLParser()
result = parser.parse(input).printTree()
if result != "#document\n" + expected:
errorAmount += 1
errorLog.append("For:\n" + input + "\nExpected:\n" + expected + "\nGot:\n" + result + "\n\n")
if errorAmount == 0:
print "All Good!"
else:
print "\n" + "".join(errorLog)
def runtests(filename):
f = open(filename)
tests = f.read().split("#data\n")
errorAmount = index = 0
errorLog = []
for index, test in enumerate(tests):
if test == "": continue
test = "#data\n" + test
input, expected, errors = parseTestcase(test)
parser = XMLParser()
result = parser.parse(input).printTree()
if result != "#document\n" + expected:
errorAmount += 1
errorLog.append("For:\n" + input + "\nExpected:\n" + expected +
"\nGot:\n" + result + "\n\n")
if errorAmount == 0:
print "All Good!"
else:
print "\n" + "".join(errorLog)
def xml_to_text(stream):
if type(stream) is str:
stream = XMLParser(stream)
encoding = 'utf-8'
text = []
for event, value, line in stream:
# TODO Extract some attribute values
if event == TEXT:
text.append(value)
elif event == XML_DECL:
encoding = value[1]
return unicode(' '.join(text), encoding)
def __init__(self,):
'''
filename - the file that contains the words
scores - dictionary containing all the letters and their score '''
self.filename = 'sowpods.txt'
self.api_key = '9832fd27-0fe4-4bc6-961a-e2e74b2d9bb9'
self.parser = XMLParser()
self.scores = {"a": 1, "c": 3, "b": 3, "e": 1, "d": 2, "g": 2,
"f": 4, "i": 1, "h": 4, "k": 5, "j": 8, "m": 3,
"l": 1, "o": 1, "n": 1, "q": 10, "p": 3, "s": 1,
"r": 1, "u": 1, "t": 1, "w": 4, "v": 4, "y": 4,
"x": 8, "z": 10}
self.load_file()
def __init__(self, xml, polly_xml=None, symsubs=None, namesubs=None):
self.functions = XMLParser(xml, symsubs, namesubs).functions
if polly_xml:
self.scops = PollyXMLParser(polly_xml).scops
else:
self.scops = []
# -*- coding: utf-8 -*-
from parser import XMLParser
from html_generator import HTMLGenerator
import sys
if __name__ == "__main__":
if len(sys.argv) != 3:
print "python " + __file__ + " <xml_file> <n_day>"
print "e.g.:"
print "> python " + __file__ + " input/schedule.xml 0"
print "for printing the schedule of the first day."
sys.exit(1)
parser = XMLParser(sys.argv[1])
conference = parser.parse()
dumper = HTMLGenerator(conference)
dumper.dump(int(sys.argv[2]))
from parser import XMLParser
parser = XMLParser()
for x in range(1, 7):
print(f"Test case {x}: ", end="")
doc = str(open(f'sample{x}/ccd.xml').read()).strip()
query = str(open(f'sample{x}/query.txt').read()).strip().replace('\n', ' ')
output = str(open(f'sample{x}/output.txt').read()).strip()
document = parser.parse(doc).find('ClinicalDocument')
if document.execute_query(query) == output:
print('Correct. Found', output)
else:
print("Incorrect. Did not find", output)
class TestAssignment(unittest.TestCase):
def setUp(self):
""" Per Test setup."""
restrictions = {"DateListed": "2016", "Description": "and"}
required_fields = ["MlsId", "MlsName", "DateListed", "StreetAddress", "Price",
"Bedrooms", "Bathrooms", "Appliances", "Rooms", "Description"]
self._initialize_xml_parser(restrictions, required_fields)
def tearDown(self):
""" Per Test tearDown"""
if os.path.isfile("results.csv"):
os.remove("results.csv")
def _initialize_xml_parser(self, restrictions, required_fields):
self._xml_parser = XMLParser(MagicMock(), MagicMock(),
restrictions, required_fields)
def _validate_format_sub_nodes_output(self, results, field, expected):
listing = MagicMock()
listing.findall.return_value = results
actual = self._xml_parser._format_sub_nodes(listing, field)
self.assertEquals(expected, actual)
def _get_mocked_results(self, values):
results = []
for value in values:
result = MagicMock()
result.text = value
results.append(result)
return results
def test_format_sub_nodes_no_results(self):
results = []
expected = ""
self._validate_format_sub_nodes_output(results, "field", expected)
def test_format_sub_nodes_one_result(self):
values = ["text"]
results = self._get_mocked_results(values)
expected = "text"
self._validate_format_sub_nodes_output(results, "field", expected)
def test_format_sub_nodes_multiple_results(self):
values = ["dog", "cat", "horse", "cow"]
results = self._get_mocked_results(values)
expected = "dog,cat,horse,cow"
self._validate_format_sub_nodes_output(results, "animals", expected)
def _validate_get_bathroom_count_output(self, results, expected):
listing = MagicMock()
listing.find.return_value = results
actual = self._xml_parser._get_bathroom_count(listing)
self.assertEquals(expected, actual)
def test_get_bathroom_count_no_values(self):
results = []
expected = '0'
self._validate_get_bathroom_count_output(results, expected)
def test_get_bathroom_count_throws_exception(self):
results = Exception
expected = '0'
self._validate_get_bathroom_count_output(results, expected)
def test_get_bathroom_count_with_values(self):
results = MagicMock()
results.text.return_value = '1'
expected = '4'
self._validate_get_bathroom_count_output(results, expected)
def _validate_get_required_fields(self, find_results, findall_results, expected):
listing = MagicMock()
listing.find.return_value = find_results
listing.findall.return_value = findall_results
actual = self._xml_parser._get_required_fields(listing)
self.assertEquals(expected, actual)
def test_get_required_fields_no_fields(self):
self._initialize_xml_parser(dict(), list())
expected = dict()
self._validate_get_required_fields("", list(), expected)
def test_get_parsed_data_no_restrictions(self):
required_fields = ["MslID", "DateListed"]
listings = [MagicMock()] * random.randrange(1, 100)
self._initialize_xml_parser(dict(), required_fields)
actual = self._xml_parser._get_parsed_data(listings)
self.assertEquals(len(listings), len(actual))
def _validate_turn_dict_to_csv(self, parsed_data, file_exists, expected):
self.assertEquals(os.path.isfile("results.csv"), False)
actual = self._xml_parser._turn_dict_to_csv(parsed_data)
self.assertEquals(os.path.isfile("results.csv"), file_exists)
self.assertEquals(actual, expected)
def test_turn_dict_to_csv_empty_dict(self):
parsed_data = dict()
file_exists = False
expected = "Unable to create CSV file."
self._validate_turn_dict_to_csv(parsed_data, file_exists, expected)
def test_turn_dict_to_csv_populated_dict(self):
parsed_data = MagicMock()
file_exists = True
expected = "Successfully created CSV file."
self._validate_turn_dict_to_csv(parsed_data, file_exists, expected)
def _initialize_xml_parser(self, restrictions, required_fields): self._xml_parser = XMLParser(MagicMock(), MagicMock(), restrictions, required_fields)
def test(string):
x = XMLParser()
tree = x.parse(string)
print tree.printTree()
class ScrabbleSolver(object):
def __init__(self,):
'''
filename - the file that contains the words
scores - dictionary containing all the letters and their score '''
self.filename = 'sowpods.txt'
self.api_key = '9832fd27-0fe4-4bc6-961a-e2e74b2d9bb9'
self.parser = XMLParser()
self.scores = {"a": 1, "c": 3, "b": 3, "e": 1, "d": 2, "g": 2,
"f": 4, "i": 1, "h": 4, "k": 5, "j": 8, "m": 3,
"l": 1, "o": 1, "n": 1, "q": 10, "p": 3, "s": 1,
"r": 1, "u": 1, "t": 1, "w": 4, "v": 4, "y": 4,
"x": 8, "z": 10}
self.load_file()
def load_file(self):
''' Open the file and load all the words from the file into a list '''
#open the word file
word_file = open(self.filename,'r')
#create an empty list to sort the lowered words
self.words = []
#traverse the file line by line and append the lowered word without the newline character([:-2]) to the list
for word in word_file:
self.words.append(word[:-2].lower())
#then we close the file
word_file.close()
def check_rack(self,rack):
'''
checks all the words from the list and compares them to the substrings in the rack
'''
#we lower the letters in the rack so AAA is equal to aaa
rack = rack.lower()
if rack == '' or any(map(lambda x: x.isdigit(), rack)):
raise ex.IncorrectRack(rack)
#create an empty list to hold the letters that we have already used
used_letters = []
#create a dictionary to hold the key=words ,value = score
self.scored_words = {}
#traverse the words list
for word in self.words:
#we create a sentinel value that at the end of every word will check if the whole word is in the rack
increment = 0
for letter in word:
#we check to see if the letter is in the rack and if the letter is not in used letter
#if it is in the used we check the count of the letter in the rack and in the word
if letter in rack and (letter not in used_letters or rack.count(letter)>=word.count(letter)):
increment += 1
used_letters.append(letter)
#after we have traversed the word,
# we check if the increment is equal to the len of the word , again to see if the whole word is in the rack
if increment == len(word):
#score the word
score = self._get_score(word)
#add the word and the score to the scored words dict
self.scored_words[word]=score
#we delete everything in the used letters so we can start over
used_letters = []
return self._bucketize(self.scored_words)
def _bucketize(self,info_dict):
'''
makes the info_dict into a dictionary with buckets containing 10 results each
'''
#we create the bucketized dict , key = bucket number, value = dict(key=word,value=score)
to_return = OrderedDict()
#we get the keys
keys = info_dict.keys()
#we check the number of buckets we should create
buckets = len(info_dict) / 10
#we loop over the number of buckets
for index in xrange(buckets):
#if buckets is >= 1 then we are sure that there are atleast 10 items
for x in xrange(10):
try:
to_return[index][keys[x]] = info_dict[keys[x]]
except KeyError:
to_return[index] = OrderedDict()
to_return[index][keys[x]] = info_dict[keys[x]]
#on every loop we make keys 10 items shorter
keys = keys[10:]
#if there are still items in list, meaning that they are less than 10
if keys:
#we set last key to 1 if the whole result is less than 10
if buckets == 0:
last_key = 1
#or to the last bucket + 1
else:
last_key = max(to_return.keys())+1
to_return[last_key] = OrderedDict()
for key in keys:
to_return[last_key][key] = info_dict[key]
return to_return
def sort(self,sort_by):
''' sorts the results by word or by score '''
if sort_by == 'word':
#we create a dictionary to hold key=word length, value = list of words with that len
sorted_len_dict = OrderedDict()
#we get the words
keys_to_sort = self.scored_words.keys()
#creating a set to held the different lens
key_lens = set((len(x) for x in keys_to_sort))
current_len = min(key_lens)
max_len = max(key_lens)
while current_len <= max_len:
for key in keys_to_sort:
if len(key) == current_len:
try:
sorted_len_dict[current_len].append(key)
except KeyError:
sorted_len_dict[current_len] = [key]
current_len += 1
#create an ordered dict to hold the actual sorted words and their scores
sorted_dict = OrderedDict()
for key,value in sorted_len_dict.items():
for val in sorted(value):
sorted_dict[val] = self.scored_words[val]
return self._bucketize(sorted_dict)
elif sort_by == 'score':
#dict to be returned
to_return = OrderedDict()
#instanciate a list
keys = self.scored_words.values()
keys.sort()
while keys:
for key in self.scored_words:
if not keys:
break
if self.scored_words[key] == keys[0]:
to_return[key] = self.scored_words[key]
keys.pop(0)
return self._bucketize(to_return)
def _get_score(self,word):
score = 0
for letter in word:
score += self.scores[letter]
return score
def get_def(self,word):
endpoint = 'http://www.dictionaryapi.com/api/v1/references/collegiate/xml/{}?key={}'.format(word,self.api_key)
result = requests.get(endpoint)
result = result.text.encode('utf-8')
try:
result = self.parser.parse(result)
except ex.NoFreeLunch as e:
e.word = word
raise e
return result
def test(string):
x = XMLParser()
tree = x.parse(string)
print tree.printTree()
