Exemplo n.º 1
0
def test_parser_expression_paren_term():
    toks = gen_tokens_for_lines(lines=["(1);"])
    parsed = Parser(toks).parse_expression()
    assert isinstance(parsed.term, ParenTerm)
from parser import Parser
import numpy as np
import pandas as pd
from glob import glob


def update_latencies(cache, to_add):
    for end in parser.endpoints:
        if cache in end.latencies.keys():
            for vid in to_add:
                end.video_lat[vid] = end.latencies[cache]


for filename in glob('data/*.in'):
    parser = Parser(filename)
    parser.parse()
    print('Wroking with file {}'.format(filename))

    for end in parser.endpoints:
        end.video_lat = [end.dc_latency] * parser.n_videos

    scores = []
    mega_string = str(parser.n_caches) + "\n"

    for cache in range(parser.n_caches):
        scores.append([])
        for video in parser.videos:
            score = 0
            for req in video.requests:
                dc_lat = parser.endpoints[req.source].video_lat[video.index]
                lat = parser.endpoints[req.source].latencies.get(cache, 0)
Exemplo n.º 3
0
from parser import Parser

url = 'https://www.bbcgoodfood.com/recipes/meatball-black-bean-chilli'
# url = 'https://www.bbcgoodfood.com/recipes/chipotle-sweet-potato-black-bean-stew-cheddar-dumplings'

Parser().get_json(url)

print(Parser().parse_html(url))
Exemplo n.º 4
0
__author__ = 'Nestor Bermudez'
__email__ = '[email protected], [email protected]'

from classifier import NaiveBayesClassifier
from singleBlockFeatureExtractor import SingleBlockFeatureExtractor
from blockGroupFeatureExtractor import BlockGroupFeatureExtractor
from unsegmentedDataParser import UnsegmentedDataParser
from parser import Parser
from util import Util

if __name__ == '__main__':
    import pdb
    import time

    start = time.clock()
    parser = UnsegmentedDataParser('extradata')
    extractor = BlockGroupFeatureExtractor()
    classifier = NaiveBayesClassifier(smoothing=1.5)
    classifier.train(extractor.items(parser.items()))
    print('Training time: ' + str((time.clock() - start) * 1000) + 'ms')

    evaluationData = Parser('part1data/yes_test.txt', 'part1data/no_test.txt')
    confusion_matrix, acc = classifier.evaluate(
        extractor.items(evaluationData.items()))
    Util.print_confusion_matrix(confusion_matrix, 2, 2)
    print('Overall accuracy: ', round(acc * 100, 2))
Exemplo n.º 5
0
 def _setup_program(self, source: str) -> ast.Program:
     lexer = Lexer(source)
     parser = Parser(lexer)
     program = parser.parse_program()
     self._check_parser_errors(parser)
     return program
Exemplo n.º 6
0
 def get_parsed(self, filename):
     if filename:
         return Parser(filename)
Exemplo n.º 7
0
    test_seed = sys.argv[2]

    root_path = "/home/edgar/ns-3-dev-git/outputs/{0}".format(test_name)
    root_name = "fat-tree-{0}_{1}_{2}.fct"

    plt.figure(1)
    color = ["r--", "g--", "b--", "y--", "k--"]
    i = 1
    for test in tests:

        ax = plt.subplot(310 + i)
        ax.set_title(test)

        color_i = 0
        for error in errors:
            fct_reader = Parser(root_path +
                                root_name.format(test, error, test_seed))
            fct = fct_reader.get_attribute("fct")

            fct_sorted = sorted(fct)

            #log scale

            #y axis step
            y = 1. * np.arange(len(fct))
            y = [x / (len(fct) - 1) for x in y]

            ##y = comulative_prob[:]

            plt.plot(fct_sorted, y, color[color_i])
            plt.xscale('log')
            color_i += 1
Exemplo n.º 8
0
    return seq

def post_append_arg_int(env, loc, seq, token):
    seq.append(int(token.value))
    return seq

def post_nothing(env, loc):
    return None

def post_pass(env, loc, arg):
    return arg

class Env(object):
    def __init__(self, symboltab, functions):
        self.symboltab = symboltab
        self.functions = functions

parse = Parser(symboltab, grammar, 'file')

def load(functions, path):
    env = Env({}, functions)
    grammar = parse.from_file(globals(), env, path)
    assert len(grammar) > 0, "empty grammar"
    return Parser(env.symboltab, grammar, grammar[0].lhs)

def load_from_string(functions, string):
    env = Env({}, functions)
    grammar = parse(globals(), env, string)
    assert len(grammar) > 0, "empty grammar"
    return Parser(env.symboltab, grammar, grammar[0].lhs)
Exemplo n.º 9
0
def load(functions, path):
    env = Env({}, functions)
    grammar = parse.from_file(globals(), env, path)
    assert len(grammar) > 0, "empty grammar"
    return Parser(env.symboltab, grammar, grammar[0].lhs)
Exemplo n.º 10
0
def run_parser(code: str) -> AST:
    tokenizer = Tokenizer(code)
    parser = Parser(tokenizer)
    ast = parser.parse()
    return ast
Exemplo n.º 11
0
    def update(self, t, column, row):
        self.simulation_time = self.simulation_time + t
        self.column = column
        self.row = row


if __name__ == "__main__":
    print(" ")
    print("----------------------------")
    print("Hashcode 2018 TEAM BING WHOO")
    print("----------------------------")
    print(" ")

    script, filename = argv
    p = Parser(filename)
    R, C, F, N, B, T = p.parse_simulator()
    rides = p.parse_rides()

    # create a simulation object.
    simulation = Simulation(R, C, F, N, B, T)
    i = 0
    # rides is a list of lists with information from input file
    # it is NOT a list of ride objects
    for ride in rides:
        # create Ride objects and add to simulation.unassigned_rides
        a, b, x, y, s, f = [x for x in ride]
        simulation.unassigned_rides.append(Ride(a, b, x, y, s, f, i))
        i += 1

    # Assign rides to each car.
Exemplo n.º 12
0
def test_parser_let(lines):
    toks = gen_tokens_for_lines(lines=lines)
    assert isinstance(Parser(toks).parse_let_statement(), LetStatement)
Exemplo n.º 13
0
def test_parser_expression_with_tail():
    toks = gen_tokens_for_lines(lines=["1 + 1 + 1;"])
    parsed = Parser(toks).parse_expression()
    assert isinstance(parsed.term, ConstantTerm)
    assert all(isinstance(t, ConstantTerm) for _, t in parsed.tail)
    assert all(o.value == "+" for o, _ in parsed.tail)
Exemplo n.º 14
0
def test_parser_expression_unary_term():
    toks = gen_tokens_for_lines(lines=["-1;"])
    parsed = Parser(toks).parse_expression()
    assert isinstance(parsed.term, UnaryOpTerm)
    assert parsed.term.op.value == "-"
Exemplo n.º 15
0
from optparse import OptionParser
from parser import Parser
from draw import Drawer

if __name__ == '__main__':
    opt_parser = OptionParser()
    opt_parser.add_option("-o",
                          "--output",
                          dest="output",
                          help="where to save the image")

    (options, args) = opt_parser.parse_args()

    try:
        parser = Parser(args[0])
        drawer = Drawer(parser.screen, parser.figures, parser.palette)
        drawer.draw()

        if vars(options)['output']:
            drawer.save(vars(options)['output'])
    except (ValueError, FileNotFoundError) as error:
        print(error)
Exemplo n.º 16
0
def load_from_string(functions, string):
    env = Env({}, functions)
    grammar = parse(globals(), env, string)
    assert len(grammar) > 0, "empty grammar"
    return Parser(env.symboltab, grammar, grammar[0].lhs)
Exemplo n.º 17
0
import socket, sys
from numpy import *
import scipy
from pyeeg import bin_power
from parser import Parser

p = Parser()

# Mindset
raw_eeg = True
spectra = []
iteration = 0

record_baseline = False

# TCP Server

try:
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
except socket.error, msg:
    sys.stderr.write("[ERROR] %s\n" % msg[1])
    sys.exit(1)

sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  #reuse tcp
sock.bind(('', 54321))
sock.listen(5)
sock.settimeout(10)

attention_prev = 0
meditation_prev = 0
Exemplo n.º 18
0
import lexer
from parser import Parser
from interpreter import Interpreter
from context import Context
while True:
    text = input("Mscript :>>> ")

    tokens, error = lexer.run('<stdin>',text)

    if error :
        print(error.as_string())
        continue

    print(tokens)
    parse = Parser(tokens)
    ast = parse.parse()

    interpreter = Interpreter()
    root_ctx = Context('<main>')
    result = interpreter.visit(ast.node,root_ctx)


    print(result.value, result.error)

    
    
Exemplo n.º 19
0
class TransactionManager:
    """Transaction Manager class."""
    parser = Parser()
    transaction_table = {}  # {transaction_id: Transaction}
    ts = 0  # timestamp
    operation_queue = []  # list of Operations

    def __init__(self):
        """
        Initialize all data managers.
        """
        self.data_manager_list = []
        for site_id in range(1, 11):
            self.data_manager_list.append(DataManager(site_id))

    def process_line(self, line):
        """Core simulation process.
        Parse input, resolve deadlock, process instructions and operations.
        :param line: one line of instruction
        :return: True if success, False if instruction is invalid
        """
        li = self.parser.parse_line(line)
        if li:
            command = li.pop(0)
            try:
                print("----- Timestamp: " + str(self.ts) + " -----")
                if self.resolve_deadlock():
                    self.execute_operation_queue()
                self.process_instruction(command, li)
                self.execute_operation_queue()
                self.ts += 1
            except InvalidInstructionError as e:
                print("[INVALID_INSTRUCTION] " + e.message +
                      ": " + line.strip())
                return False
            # finally:
            #     print()
        return True

    def process_instruction(self, command, args):
        """
        Process an instruction.
        If the instruction is Read or Write, add it to the operation queue.
        Otherwise, execute the instruction directly.
        :param command: "begin", "beginRO", "R", "W", "dump", "end", "fail",
         or "recover"
        :param args: list of arguments for a command
        """
        if command == "begin":
            self.begin(args[0])
        elif command == "beginRO":
            self.beginro(args[0])
        elif command == "R":
            self.add_read_operation(args[0], args[1])
        elif command == "W":
            self.add_write_operation(args[0], args[1], args[2])
        elif command == "dump":
            self.dump()
        elif command == "end":
            self.end(args[0])
        elif command == "fail":
            self.fail(int(args[0]))
        elif command == "recover":
            self.recover(int(args[0]))
        else:
            raise InvalidInstructionError("Unknown instruction")

    def add_read_operation(self, transaction_id, variable_id):
        """
        Insert a Read Operation to the operation queue
        :param transaction_id: the id of the transaction performing this op
        :param variable_id: the id of the variable
        """
        if not self.transaction_table.get(transaction_id):
            raise InvalidInstructionError(
                "Transaction {} does not exist".format(transaction_id))
        self.operation_queue.append(
            Operation("R", transaction_id, variable_id))

    def add_write_operation(self, transaction_id, variable_id, value):
        """
        Insert a Write Operation to the operation queue
        :param transaction_id: the id of the transaction performing this op
        :param variable_id: the id of the variable
        :param value: write value
        """
        if not self.transaction_table.get(transaction_id):
            raise InvalidInstructionError(
                "Transaction {} does not exist".format(transaction_id))
        self.operation_queue.append(
            Operation("W", transaction_id, variable_id, value))

    def execute_operation_queue(self):
        """Go through operation queue and execute any executable operations."""
        for op in list(self.operation_queue):
            if not self.transaction_table.get(op.transaction_id):
                self.operation_queue.remove(op)
            else:
                success = False
                if op.command == "R":
                    if self.transaction_table[op.transaction_id].is_ro:
                        success = self.read_snapshot(op.transaction_id,
                                                     op.variable_id)
                    else:
                        success = self.read(op.transaction_id, op.variable_id)
                elif op.command == "W":
                    success = self.write(op.transaction_id, op.variable_id,
                                         op.value)
                else:
                    print("Invalid operation!")
                if success:
                    # print("Executed op: {}".format(op))
                    self.operation_queue.remove(op)
        # print("Remaining ops: {}".format(self.operation_queue))

    # -----------------------------------------------------
    # -------------- Instruction Executions ---------------
    # -----------------------------------------------------
    def begin(self, transaction_id):
        if self.transaction_table.get(transaction_id):
            raise InvalidInstructionError(
                "{} already exists".format(transaction_id))
        self.transaction_table[transaction_id] = Transaction(
            self.ts, transaction_id, False)
        print("{} begins".format(transaction_id))

    def beginro(self, transaction_id):
        if self.transaction_table.get(transaction_id):
            raise InvalidInstructionError(
                "{} already exists".format(transaction_id))
        self.transaction_table[transaction_id] = Transaction(
            self.ts, transaction_id, True)
        print("{} begins and is read-only".format(transaction_id))

    def read_snapshot(self, transaction_id, variable_id):
        """Perform read operation for read-only transactions."""
        if not self.transaction_table.get(transaction_id):
            raise InvalidInstructionError(
                "Transaction {} does not exist".format(transaction_id))
        ts = self.transaction_table[transaction_id].ts
        for dm in self.data_manager_list:
            if dm.is_up and dm.has_variable(variable_id):
                # pass the transaction's begin time into each data manager
                # when doing read-only
                result = dm.read_snapshot(variable_id, ts)
                if result.success:
                    print("{} (RO) reads {}.{}: {}".format(
                        transaction_id, variable_id, dm.site_id, result.value))
                    return True
        return False

    def read(self, transaction_id, variable_id):
        """Perform read operation for normal transactions."""
        if not self.transaction_table.get(transaction_id):
            raise InvalidInstructionError(
                "Transaction {} does not exist".format(transaction_id))
        for dm in self.data_manager_list:
            if dm.is_up and dm.has_variable(variable_id):
                result = dm.read(transaction_id, variable_id)
                if result.success:
                    self.transaction_table[
                        transaction_id].sites_accessed.append(dm.site_id)
                    print("{} reads {}.{}: {}".format(
                        transaction_id, variable_id, dm.site_id, result.value))
                    return True
        return False

    def write(self, transaction_id, variable_id, value):
        if not self.transaction_table.get(transaction_id):
            raise InvalidInstructionError(
                "Transaction {} does not exist".format(transaction_id))
        all_relevant_sites_down = True
        can_get_all_write_locks = True
        for dm in self.data_manager_list:
            if dm.is_up and dm.has_variable(variable_id):
                # check if all the relevant sites are down now
                all_relevant_sites_down = False
                result = dm.get_write_lock(transaction_id, variable_id)
                if not result:
                    can_get_all_write_locks = False

        if not all_relevant_sites_down and can_get_all_write_locks:
            # print("{} will write {} with value {}".format(
            #     transaction_id, variable_id, value))
            sites_written = []
            for dm in self.data_manager_list:
                if dm.is_up and dm.has_variable(variable_id):
                    dm.write(transaction_id, variable_id, value)
                    self.transaction_table[
                        transaction_id].sites_accessed.append(dm.site_id)
                    sites_written.append(dm.site_id)
            print("{} writes {} with value {} to sites {}".format(
                transaction_id, variable_id, value, sites_written))
            return True
        return False

    def dump(self):
        print("Dump:")
        for dm in self.data_manager_list:
            dm.dump()

    def end(self, transaction_id):
        """Commit or abort a transaction depending its status."""
        if not self.transaction_table.get(transaction_id):
            raise InvalidInstructionError(
                "Transaction {} does not exist".format(transaction_id))
        if self.transaction_table[transaction_id].will_abort:
            self.abort(transaction_id, True)
        else:
            self.commit(transaction_id, self.ts)

    def abort(self, transaction_id, due_to_site_fail=False):
        """Abort a transaction."""
        for dm in self.data_manager_list:
            dm.abort(transaction_id)
        self.transaction_table.pop(transaction_id)
        if due_to_site_fail:
            print("{} aborts! (due to site failure)".format(transaction_id))
        else:
            print("{} aborts! (due to deadlock)".format(transaction_id))

    def commit(self, transaction_id, commit_ts):
        """Commit a transaction."""
        for dm in self.data_manager_list:
            dm.commit(transaction_id, commit_ts)
        self.transaction_table.pop(transaction_id)
        print("{} commits!".format(transaction_id))

    def fail(self, site_id):
        """Site fails."""
        dm = self.data_manager_list[site_id - 1]
        if not dm.is_up:
            raise InvalidInstructionError(
                "Site {} is already down".format(site_id))
        dm.fail(self.ts)
        print("Site {} fails".format(site_id))
        for t in self.transaction_table.values():
            if (not t.is_ro) and (not t.will_abort) and (
                    site_id in t.sites_accessed):
                # not applied to read-only transaction
                t.will_abort = True
                # print("{} will abort!!!".format(t.transaction_id))

    def recover(self, site_id):
        """Site recovers."""
        dm = self.data_manager_list[site_id - 1]
        if dm.is_up:
            raise InvalidInstructionError(
                "Site {} is already up".format(site_id))
        dm.recover(self.ts)
        print("Site {} recovers".format(site_id))

    # -----------------------------------------------------
    # ---------------- Deadlock Detection -----------------
    # -----------------------------------------------------
    def resolve_deadlock(self):
        """
        Detect deadlocks using cycle detection and abort the youngest
        transaction in the cycle.
        :return: True if a deadlock is resolved, False if no deadlock detected
        """
        blocking_graph = defaultdict(set)
        for dm in self.data_manager_list:
            if dm.is_up:
                graph = dm.generate_blocking_graph()
                for node, adj_list in graph.items():
                    blocking_graph[node].update(adj_list)
        # print(dict(blocking_graph))
        youngest_t_id = None
        youngest_ts = -1
        for node in list(blocking_graph.keys()):
            visited = set()
            if has_cycle(node, node, visited, blocking_graph):
                if self.transaction_table[node].ts > youngest_ts:
                    youngest_t_id = node
                    youngest_ts = self.transaction_table[node].ts
        if youngest_t_id:
            print("Deadlock detected: aborting {}".format(youngest_t_id))
            self.abort(youngest_t_id)
            return True
        return False
 def __init__(self, database):
     self._collator = Collator(database)
     self._extractor = Extractor()
     self._parser = Parser()
Exemplo n.º 21
0
    ## wikidata.links is a dictionary of type: entity -> set(entity).
    ##                It represents all the entities connected to a
    ##                given entity in the yago graph
    ## wikidata.labels is a dictionary of type: entity -> set(label).
    ##                It represents all the labels an entity can have.
    ## wikidata.rlabels is a dictionary of type: label -> set(entity).
    ##                It represents all the entities sharing a same label.
    ## wikidata.dates is a dictionnary of type: entity -> set(date).
    ##                It represents all the dates associated to an entity.

    # Note that the class Page has a method Page.label(),
    # which retrieves the human-readable label of the title of an
    # ambiguous Wikipedia page.

    with open(outputFile, 'w', encoding="utf-8") as output:
        for page in Parser(wikipediaFile):
            # DO NOT MODIFY THE CODE ABOVE THIS POINT
            # or you may not be evaluated (you can add imports).

            # YOUR CODE GOES HERE:

            ################ Methode 1: F-score: 7 precision 24 ##################
            # print("page.label() \n", page.label())
            # print("page.content \n", page.content)
            # rlabel = list(wikidata.rlabels[page.label()])[0]
            # link = wikidata.links[rlabel]
            # Q_link0 = list(link)[0]
            # labels = wikidata.labels[Q_link0]

            # sent = set(page.content)
            # word_label = list(labels)[0]
Exemplo n.º 22
0
 def getSimplecVector(self, myFile):
     parser = Parser()
     text = parser.parseText(myFile)
     vector = parser.createSimpleVector(text)
     return vector
Exemplo n.º 23
0
import sys
import urllib3
import subprocess
from parser import Parser
from fragQueue import FragQueue
from errors import StatusError, NotManifestError
from interval import RepeatedTimer
from log import log
http = urllib3.PoolManager(cert_reqs='CERT_NONE')
urllib3.disable_warnings()


outDir = './manifest'
parser = Parser()

fragStorageBase = 'frags'
RECORDING_TIME = 6

urlInput = input('Enter Manifest Url: ')
if not urlInput:
    urlInput = 'http://localhost:8880/remote/level.m3u8?url=https://test-streams.mux.dev/x36xhzz/url_0/193039199_mp4_h264_aac_hd_7.m3u8'
referer = input('Enter Referer (optional): ')
recordTime = input('Input Recording time in hours (default 6): ')
if recordTime:
    RECORDING_TIME = float(recordTime)
# if not input('Log to file? '):
sys.stdout = open('./python-output.txt', 'w+')

stopAfter = 60 * 60 * RECORDING_TIME

POLL_INTERVAL = 4
Exemplo n.º 24
0
 def __init__(self):
     self.pr = Parser()
     self.log = ""
     self.t = Thread()
Exemplo n.º 25
0
from loader import executeFromString
from parser import Parser
from prompt_toolkit import prompt
from prompt_toolkit.history import FileHistory

if __name__ == '__main__':

    grammarFile = 'grammars/JJ.g'
    parser = Parser(grammarFile)

    history = []
    stack = []
    while True:
        code = prompt('>>> ', history=FileHistory('history.txt'))

        if code == 'quit':
            break
        elif code == '_':
            if history:
                stack = history[-1]
            else:
                stack = []
            print(stack)
        else:
            try:
                stack = executeFromString(code, parser, stack=stack)
                history.append(stack)
            except Exception as error:
                raise error
                continue
Exemplo n.º 26
0
#         _init(4, 1, 5)
#         print(look)
#     done
# """

# text = r"""
#     var FINISH
#
#     function main()
#     do
#         FINISH[0] := -1
#         FINISH[1] := -1
#         FINISH[2] := -1
#
#     done
# """

# text = r"""
#     function main()
#     do
#         a[1][2][3] := 3
#     done
# """

parser = Parser(yacc_debug=True)
ast = parser.parse(text, filename='<none>', debuglevel=False)
ast.show(attrnames=True, showcoord=True)

exec = nodevisitor.NodeVisitor(parser._err_flag, parser.tokens)
exec.visit(ast, entry_point=exec.scopes['__global'])
Exemplo n.º 27
0
    return lines


def split_lines(lines, separator=" "):
    splited_lines = []
    for line in lines:
        splited_line = line.strip().split(separator)
        for i, element in enumerate(splited_line):
            try:
                splited_lines[i].append(element)
            except IndexError:
                splited_lines += [[element]]
    return splited_lines


def plot_cwnd(time, cwnd, fig_name):
    plt.plot(time, cwnd, 'ro')
    #    plt.axis([0, float(max(time)), 0, float(max(cwnd))])
    plt.savefig(fig_name + '.png')
    plt.show()


if __name__ == "__main__":

    parser = Parser(sys.argv[1], {'time': 0, 'cwnd': 1}, " ")

    time = parser.get_attribute('time')
    cwnd = parser.get_attribute('cwnd')

    plot_cwnd(time, cwnd, sys.argv[2])
Exemplo n.º 28
0
from parser import Parser

parse = Parser()


class Assembler():

    # Read file,
    # return assembly buffer.
    def assemble_file(self, filename):
        f = open(filename, "r")

        lines = f.readlines()
        assembly = parse.lines_to_assembly(lines)
        buf = parse.assembly_to_buffer(assembly)

        f.close()

        return buf

    # Assemble input file,
    # write assembly to output file.
    def assemble(self, filename_in, filename_out):
        assembly = self.assemble_file(filename_in)

        f = open(filename_out, "w")

        for b in assembly:
            f.write(b)

        f.close()
Exemplo n.º 29
0
 def parse(self, input, print_nodes=False):
   parser = Parser(input)
   if(print_nodes): parser.print_nodes()
   return parser.scene
Exemplo n.º 30
0
        node.sibling = creat_node(dt, total, num + 1)
    elif num == total:
        node.sibling = None
    return node


def traverse_tree(node):
    print(node.name)
    if node.child is not None:
        traverse_tree(node.child)

    if node.sibling is not None:
        traverse_tree(node.sibling)


with open("syntax-tree.json", 'r') as load_f:
    load_dict = json.load(load_f)
    root = SyntaxTree()
    root.name = load_dict['content']
    root.name = load_dict['name']
    root.line = load_dict['line']

    dt = load_dict['children']
    root.child = creat_node(dt, len(dt) - 1, 0)
    root.sibling = None

    traverse_tree(root)

    parser = Parser(root)